The base class for convex polyhedra. More...

#include <Polyhedron_defs.hh>

Inheritance diagram for Parma_Polyhedra_Library::Polyhedron:

Collaboration diagram for Parma_Polyhedra_Library::Polyhedron:

[legend]

Classes
class	Status
	A conjunctive assertion about a polyhedron. More...

Public Types
typedef Coefficient	coefficient_type
	The numeric type of coefficients. More...

Public Member Functions
template<typename Input >
Input &	check_obj_space_dimension_overflow (Input &input, const Topology topol, const char method, const char reason)

Member Functions that Do Not Modify the Polyhedron
dimension_type	space_dimension () const
	Returns the dimension of the vector space enclosing `*this`. More...

dimension_type	affine_dimension () const
	Returns , if `this` is empty; otherwise, returns the affine dimension of `this`. More...

const Constraint_System &	constraints () const
	Returns the system of constraints. More...

const Constraint_System &	minimized_constraints () const
	Returns the system of constraints, with no redundant constraint. More...

const Generator_System &	generators () const
	Returns the system of generators. More...

const Generator_System &	minimized_generators () const
	Returns the system of generators, with no redundant generator. More...

Congruence_System	congruences () const
	Returns a system of (equality) congruences satisfied by `*this`. More...

Congruence_System	minimized_congruences () const
	Returns a system of (equality) congruences satisfied by `this`, with no redundant congruences and having the same affine dimension as `this`. More...

Poly_Con_Relation	relation_with (const Constraint &c) const
	Returns the relations holding between the polyhedron `*this` and the constraint `c`. More...

Poly_Gen_Relation	relation_with (const Generator &g) const
	Returns the relations holding between the polyhedron `*this` and the generator `g`. More...

Poly_Con_Relation	relation_with (const Congruence &cg) const
	Returns the relations holding between the polyhedron `*this` and the congruence `c`. More...

bool	is_empty () const
	Returns `true` if and only if `*this` is an empty polyhedron. More...

bool	is_universe () const
	Returns `true` if and only if `*this` is a universe polyhedron. More...

bool	is_topologically_closed () const
	Returns `true` if and only if `*this` is a topologically closed subset of the vector space. More...

bool	is_disjoint_from (const Polyhedron &y) const
	Returns `true` if and only if `*this` and `y` are disjoint. More...

bool	is_discrete () const
	Returns `true` if and only if `*this` is discrete. More...

bool	is_bounded () const
	Returns `true` if and only if `*this` is a bounded polyhedron. More...

bool	contains_integer_point () const
	Returns `true` if and only if `*this` contains at least one integer point. More...

bool	constrains (Variable var) const
	Returns `true` if and only if `var` is constrained in `*this`. More...

bool	bounds_from_above (const Linear_Expression &expr) const
	Returns `true` if and only if `expr` is bounded from above in `*this`. More...

bool	bounds_from_below (const Linear_Expression &expr) const
	Returns `true` if and only if `expr` is bounded from below in `*this`. More...

bool	maximize (const Linear_Expression &expr, Coefficient &sup_n, Coefficient &sup_d, bool &maximum) const
	Returns `true` if and only if `this` is not empty and `expr` is bounded from above in `this`, in which case the supremum value is computed. More...

bool	maximize (const Linear_Expression &expr, Coefficient &sup_n, Coefficient &sup_d, bool &maximum, Generator &g) const
	Returns `true` if and only if `this` is not empty and `expr` is bounded from above in `this`, in which case the supremum value and a point where `expr` reaches it are computed. More...

bool	minimize (const Linear_Expression &expr, Coefficient &inf_n, Coefficient &inf_d, bool &minimum) const
	Returns `true` if and only if `this` is not empty and `expr` is bounded from below in `this`, in which case the infimum value is computed. More...

bool	minimize (const Linear_Expression &expr, Coefficient &inf_n, Coefficient &inf_d, bool &minimum, Generator &g) const
	Returns `true` if and only if `this` is not empty and `expr` is bounded from below in `this`, in which case the infimum value and a point where `expr` reaches it are computed. More...

bool	frequency (const Linear_Expression &expr, Coefficient &freq_n, Coefficient &freq_d, Coefficient &val_n, Coefficient &val_d) const
	Returns `true` if and only if there exist a unique value `val` such that `*this` saturates the equality `expr = val`. More...

bool	contains (const Polyhedron &y) const
	Returns `true` if and only if `*this` contains `y`. More...

bool	strictly_contains (const Polyhedron &y) const
	Returns `true` if and only if `*this` strictly contains `y`. More...

bool	OK (bool check_not_empty=false) const
	Checks if all the invariants are satisfied. More...

Space Dimension Preserving Member Functions that May Modify the Polyhedron
void	add_constraint (const Constraint &c)
	Adds a copy of constraint `c` to the system of constraints of `*this` (without minimizing the result). More...

void	add_generator (const Generator &g)
	Adds a copy of generator `g` to the system of generators of `*this` (without minimizing the result). More...

void	add_congruence (const Congruence &cg)
	Adds a copy of congruence `cg` to `*this`, if `cg` can be exactly represented by a polyhedron. More...

void	add_constraints (const Constraint_System &cs)
	Adds a copy of the constraints in `cs` to the system of constraints of `*this` (without minimizing the result). More...

void	add_recycled_constraints (Constraint_System &cs)
	Adds the constraints in `cs` to the system of constraints of `*this` (without minimizing the result). More...

void	add_generators (const Generator_System &gs)
	Adds a copy of the generators in `gs` to the system of generators of `*this` (without minimizing the result). More...

void	add_recycled_generators (Generator_System &gs)
	Adds the generators in `gs` to the system of generators of `*this` (without minimizing the result). More...

void	add_congruences (const Congruence_System &cgs)
	Adds a copy of the congruences in `cgs` to `*this`, if all the congruences can be exactly represented by a polyhedron. More...

void	add_recycled_congruences (Congruence_System &cgs)
	Adds the congruences in `cgs` to `*this`, if all the congruences can be exactly represented by a polyhedron. More...

void	refine_with_constraint (const Constraint &c)
	Uses a copy of constraint `c` to refine `*this`. More...

void	refine_with_congruence (const Congruence &cg)
	Uses a copy of congruence `cg` to refine `*this`. More...

void	refine_with_constraints (const Constraint_System &cs)
	Uses a copy of the constraints in `cs` to refine `*this`. More...

void	refine_with_congruences (const Congruence_System &cgs)
	Uses a copy of the congruences in `cgs` to refine `*this`. More...

template<typename FP_Format , typename Interval_Info >
void	refine_with_linear_form_inequality (const Linear_Form< Interval< FP_Format, Interval_Info > > &left, const Linear_Form< Interval< FP_Format, Interval_Info > > &right, bool is_strict=false)
	Refines `*this` with the constraint expressed by `left` `right` if `is_strict` is set, with the constraint `left` $\leq$ `right` otherwise. More...

template<typename FP_Format , typename Interval_Info >
void	generalized_refine_with_linear_form_inequality (const Linear_Form< Interval< FP_Format, Interval_Info > > &left, const Linear_Form< Interval< FP_Format, Interval_Info > > &right, Relation_Symbol relsym)
	Refines `*this` with the constraint expressed by `left` $\relsym$ `right`, where $\relsym$ is the relation symbol specified by `relsym`.. More...

template<typename FP_Format , typename Interval_Info >
void	refine_fp_interval_abstract_store (Box< Interval< FP_Format, Interval_Info > > &store) const
	Refines `store` with the constraints defining `*this`. More...

void	unconstrain (Variable var)
	Computes the cylindrification of `this` with respect to space dimension `var`, assigning the result to `this`. More...

void	unconstrain (const Variables_Set &vars)
	Computes the cylindrification of `this` with respect to the set of space dimensions `vars`, assigning the result to `this`. More...

void	intersection_assign (const Polyhedron &y)
	Assigns to `this` the intersection of `this` and `y`. More...

void	poly_hull_assign (const Polyhedron &y)
	Assigns to `this` the poly-hull of `this` and `y`. More...

void	upper_bound_assign (const Polyhedron &y)
	Same as poly_hull_assign(y). More...

void	poly_difference_assign (const Polyhedron &y)
	Assigns to `this` the poly-difference of `this` and `y`. More...

void	difference_assign (const Polyhedron &y)
	Same as poly_difference_assign(y). More...

bool	simplify_using_context_assign (const Polyhedron &y)
	Assigns to `this` a meet-preserving simplification of `this` with respect to `y`. If `false` is returned, then the intersection is empty. More...

void	affine_image (Variable var, const Linear_Expression &expr, Coefficient_traits::const_reference denominator=Coefficient_one())
	Assigns to `this` the affine image of `this` under the function mapping variable `var` to the affine expression specified by `expr` and `denominator`. More...

template<typename FP_Format , typename Interval_Info >
void	affine_form_image (Variable var, const Linear_Form< Interval< FP_Format, Interval_Info > > &lf)

void	affine_preimage (Variable var, const Linear_Expression &expr, Coefficient_traits::const_reference denominator=Coefficient_one())
	Assigns to `this` the affine preimage of `this` under the function mapping variable `var` to the affine expression specified by `expr` and `denominator`. More...

void	generalized_affine_image (Variable var, Relation_Symbol relsym, const Linear_Expression &expr, Coefficient_traits::const_reference denominator=Coefficient_one())
	Assigns to `this` the image of `this` with respect to the generalized affine relation $\mathrm{var}' \relsym \frac{\mathrm{expr}}{\mathrm{denominator}}$ , where $\mathord{\relsym}$ is the relation symbol encoded by `relsym`. More...

void	generalized_affine_preimage (Variable var, Relation_Symbol relsym, const Linear_Expression &expr, Coefficient_traits::const_reference denominator=Coefficient_one())
	Assigns to `this` the preimage of `this` with respect to the generalized affine relation $\mathrm{var}' \relsym \frac{\mathrm{expr}}{\mathrm{denominator}}$ , where $\mathord{\relsym}$ is the relation symbol encoded by `relsym`. More...

void	generalized_affine_image (const Linear_Expression &lhs, Relation_Symbol relsym, const Linear_Expression &rhs)
	Assigns to `this` the image of `this` with respect to the generalized affine relation $\mathrm{lhs}' \relsym \mathrm{rhs}$ , where $\mathord{\relsym}$ is the relation symbol encoded by `relsym`. More...

void	generalized_affine_preimage (const Linear_Expression &lhs, Relation_Symbol relsym, const Linear_Expression &rhs)
	Assigns to `this` the preimage of `this` with respect to the generalized affine relation $\mathrm{lhs}' \relsym \mathrm{rhs}$ , where $\mathord{\relsym}$ is the relation symbol encoded by `relsym`. More...

void	bounded_affine_image (Variable var, const Linear_Expression &lb_expr, const Linear_Expression &ub_expr, Coefficient_traits::const_reference denominator=Coefficient_one())
	Assigns to `this` the image of `this` with respect to the bounded affine relation $\frac{\mathrm{lb\_expr}}{\mathrm{denominator}} \leq \mathrm{var}' \leq \frac{\mathrm{ub\_expr}}{\mathrm{denominator}}$ . More...

void	bounded_affine_preimage (Variable var, const Linear_Expression &lb_expr, const Linear_Expression &ub_expr, Coefficient_traits::const_reference denominator=Coefficient_one())
	Assigns to `this` the preimage of `this` with respect to the bounded affine relation $\frac{\mathrm{lb\_expr}}{\mathrm{denominator}} \leq \mathrm{var}' \leq \frac{\mathrm{ub\_expr}}{\mathrm{denominator}}$ . More...

void	time_elapse_assign (const Polyhedron &y)
	Assigns to `this` the result of computing the time-elapse between `this` and `y`. More...

void	positive_time_elapse_assign (const Polyhedron &y)
	Assigns to `this` (the best approximation of) the result of computing the positive time-elapse between `this` and `y`. More...

void	wrap_assign (const Variables_Set &vars, Bounded_Integer_Type_Width w, Bounded_Integer_Type_Representation r, Bounded_Integer_Type_Overflow o, const Constraint_System *cs_p=0, unsigned complexity_threshold=16, bool wrap_individually=true)
	Wraps the specified dimensions of the vector space. More...

void	drop_some_non_integer_points (Complexity_Class complexity=ANY_COMPLEXITY)
	Possibly tightens `*this` by dropping some points with non-integer coordinates. More...

void	drop_some_non_integer_points (const Variables_Set &vars, Complexity_Class complexity=ANY_COMPLEXITY)
	Possibly tightens `*this` by dropping some points with non-integer coordinates for the space dimensions corresponding to `vars`. More...

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

void	BHRZ03_widening_assign (const Polyhedron &y, unsigned *tp=0)
	Assigns to `this` the result of computing the BHRZ03-widening between `this` and `y`. More...

void	limited_BHRZ03_extrapolation_assign (const Polyhedron &y, const Constraint_System &cs, unsigned *tp=0)
	Assigns to `this` the result of computing the limited extrapolation between `this` and `y` using the BHRZ03-widening operator. More...

void	bounded_BHRZ03_extrapolation_assign (const Polyhedron &y, const Constraint_System &cs, unsigned *tp=0)
	Assigns to `this` the result of computing the bounded extrapolation between `this` and `y` using the BHRZ03-widening operator. More...

void	H79_widening_assign (const Polyhedron &y, unsigned *tp=0)
	Assigns to `this` the result of computing the H79_widening between `this` and `y`. More...

void	widening_assign (const Polyhedron &y, unsigned *tp=0)
	Same as H79_widening_assign(y, tp). More...

void	limited_H79_extrapolation_assign (const Polyhedron &y, const Constraint_System &cs, unsigned *tp=0)
	Assigns to `this` the result of computing the limited extrapolation between `this` and `y` using the H79-widening operator. More...

void	bounded_H79_extrapolation_assign (const Polyhedron &y, const Constraint_System &cs, unsigned *tp=0)
	Assigns to `this` the result of computing the bounded extrapolation between `this` and `y` using the H79-widening operator. More...

Member Functions that May Modify the Dimension of the Vector Space
void	add_space_dimensions_and_embed (dimension_type m)
	Adds `m` new space dimensions and embeds the old polyhedron in the new vector space. More...

void	add_space_dimensions_and_project (dimension_type m)
	Adds `m` new space dimensions to the polyhedron and does not embed it in the new vector space. More...

void	concatenate_assign (const Polyhedron &y)
	Assigns to `this` the concatenation of `this` and `y`, taken in this order. More...

void	remove_space_dimensions (const Variables_Set &vars)
	Removes all the specified dimensions from the vector space. More...

void	remove_higher_space_dimensions (dimension_type new_dimension)
	Removes the higher dimensions of the vector space so that the resulting space will have dimension `new_dimension`. More...

template<typename Partial_Function >
void	map_space_dimensions (const Partial_Function &pfunc)
	Remaps the dimensions of the vector space according to a partial function. More...

void	expand_space_dimension (Variable var, dimension_type m)
	Creates `m` copies of the space dimension corresponding to `var`. More...

void	fold_space_dimensions (const Variables_Set &vars, Variable dest)
	Folds the space dimensions in `vars` into `dest`. More...

Miscellaneous Member Functions
	~Polyhedron ()
	Destructor. More...

void	m_swap (Polyhedron &y)
	Swaps `this` with polyhedron `y`. (`this` and `y` can be dimension-incompatible.) More...

void	ascii_dump () const
	Writes to `std::cerr` an ASCII representation of `*this`. More...

void	ascii_dump (std::ostream &s) const
	Writes to `s` an ASCII representation of `*this`. More...

void	print () const
	Prints `*this` to `std::cerr` using `operator<<`. More...

bool	ascii_load (std::istream &s)
	Loads from `s` an ASCII representation (as produced by ascii_dump(std::ostream&) const) and sets `*this` accordingly. Returns `true` if successful, `false` otherwise. More...

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...

int32_t	hash_code () const
	Returns a 32-bit hash code for `*this`. More...

Static Public Member Functions
static dimension_type	max_space_dimension ()
	Returns the maximum space dimension all kinds of Polyhedron can handle. More...

static bool	can_recycle_constraint_systems ()
	Returns `true` indicating that this domain has methods that can recycle constraints. More...

static void	initialize ()
	Initializes the class. More...

static void	finalize ()
	Finalizes the class. More...

static bool	can_recycle_congruence_systems ()
	Returns `false` indicating that this domain cannot recycle congruences. More...

Protected Member Functions
	Polyhedron (Topology topol, dimension_type num_dimensions, Degenerate_Element kind)
	Builds a polyhedron having the specified properties. More...

	Polyhedron (const Polyhedron &y, Complexity_Class complexity=ANY_COMPLEXITY)
	Ordinary copy constructor. More...

	Polyhedron (Topology topol, const Constraint_System &cs)
	Builds a polyhedron from a system of constraints. More...

	Polyhedron (Topology topol, Constraint_System &cs, Recycle_Input dummy)
	Builds a polyhedron recycling a system of constraints. More...

	Polyhedron (Topology topol, const Generator_System &gs)
	Builds a polyhedron from a system of generators. More...

	Polyhedron (Topology topol, Generator_System &gs, Recycle_Input dummy)
	Builds a polyhedron recycling a system of generators. More...

template<typename Interval >
	Polyhedron (Topology topol, const Box< Interval > &box, Complexity_Class complexity=ANY_COMPLEXITY)
	Builds a polyhedron from a box. More...

Polyhedron &	operator= (const Polyhedron &y)
	The assignment operator. (`*this` and `y` can be dimension-incompatible.) More...

bool	BFT00_poly_hull_assign_if_exact (const Polyhedron &y)
	If the poly-hull of `this` and `y` is exact it is assigned to `this` and `true` is returned, otherwise `false` is returned. More...

bool	BHZ09_poly_hull_assign_if_exact (const Polyhedron &y)

bool	BHZ09_C_poly_hull_assign_if_exact (const Polyhedron &y)

bool	BHZ09_NNC_poly_hull_assign_if_exact (const Polyhedron &y)

void	drop_some_non_integer_points (const Variables_Set *vars_p, Complexity_Class complexity)
	Possibly tightens `this` by dropping some points with non-integer coordinates for the space dimensions corresponding to `vars_p`. More...

template<typename FP_Format , typename Interval_Info >
void	overapproximate_linear_form (const Linear_Form< Interval< FP_Format, Interval_Info > > &lf, const dimension_type lf_dimension, Linear_Form< Interval< FP_Format, Interval_Info > > &result)
	Helper function that overapproximates an interval linear form. More...

void	positive_time_elapse_assign_impl (const Polyhedron &y)
	Assuming `this` is NNC, assigns to `this` the result of the "positive time-elapse" between `*this` and `y`. More...

Static Protected Member Functions
template<typename FP_Format , typename Interval_Info >
static void	convert_to_integer_expression (const Linear_Form< Interval< FP_Format, Interval_Info > > &lf, const dimension_type lf_dimension, Linear_Expression &result)
	Helper function that makes `result` become a Linear_Expression obtained by normalizing the denominators in `lf`. More...

template<typename FP_Format , typename Interval_Info >
static void	convert_to_integer_expressions (const Linear_Form< Interval< FP_Format, Interval_Info > > &lf, const dimension_type lf_dimension, Linear_Expression &res, Coefficient &res_low_coeff, Coefficient &res_hi_coeff, Coefficient &denominator)
	Normalization helper function. More...

template<typename Linear_System1 , typename Row2 >
static bool	add_to_system_and_check_independence (Linear_System1 &eq_sys, const Row2 &eq)

Private Types
enum	Three_Valued_Boolean { TVB_TRUE, TVB_FALSE, TVB_DONT_KNOW }

Private Member Functions
Topology	topology () const
	Returns the topological kind of the polyhedron. More...

bool	is_necessarily_closed () const
	Returns `true` if and only if the polyhedron is necessarily closed. More...

void	refine_no_check (const Constraint &c)
	Uses a copy of constraint `c` to refine the system of constraints of `*this`. More...

Three_Valued_Boolean	quick_equivalence_test (const Polyhedron &y) const
	Polynomial but incomplete equivalence test between polyhedra. More...

bool	is_included_in (const Polyhedron &y) const
	Returns `true` if and only if `*this` is included in `y`. More...

bool	bounds (const Linear_Expression &expr, bool from_above) const
	Checks if and how `expr` is bounded in `*this`. More...

bool	max_min (const Linear_Expression &expr, bool maximize, Coefficient &ext_n, Coefficient &ext_d, bool &included, Generator &g) const
	Maximizes or minimizes `expr` subject to `*this`. More...

Private Verifiers: Verify if Individual Flags are Set
bool	marked_empty () const
	Returns `true` if the polyhedron is known to be empty. More...

bool	constraints_are_up_to_date () const
	Returns `true` if the system of constraints is up-to-date. More...

bool	generators_are_up_to_date () const
	Returns `true` if the system of generators is up-to-date. More...

bool	constraints_are_minimized () const
	Returns `true` if the system of constraints is minimized. More...

bool	generators_are_minimized () const
	Returns `true` if the system of generators is minimized. More...

bool	has_pending_constraints () const
	Returns `true` if there are pending constraints. More...

bool	has_pending_generators () const
	Returns `true` if there are pending generators. More...

bool	has_something_pending () const
	Returns `true` if there are either pending constraints or pending generators. More...

bool	can_have_something_pending () const
	Returns `true` if the polyhedron can have something pending. More...

bool	sat_c_is_up_to_date () const
	Returns `true` if the saturation matrix `sat_c` is up-to-date. More...

bool	sat_g_is_up_to_date () const
	Returns `true` if the saturation matrix `sat_g` is up-to-date. More...

State Flag Setters: Set Only the Specified Flags
void	set_zero_dim_univ ()
	Sets `status` to express that the polyhedron is the universe 0-dimension vector space, clearing all corresponding matrices. More...

void	set_empty ()
	Sets `status` to express that the polyhedron is empty, clearing all corresponding matrices. More...

void	set_constraints_up_to_date ()
	Sets `status` to express that constraints are up-to-date. More...

void	set_generators_up_to_date ()
	Sets `status` to express that generators are up-to-date. More...

void	set_constraints_minimized ()
	Sets `status` to express that constraints are minimized. More...

void	set_generators_minimized ()
	Sets `status` to express that generators are minimized. More...

void	set_constraints_pending ()
	Sets `status` to express that constraints are pending. More...

void	set_generators_pending ()
	Sets `status` to express that generators are pending. More...

void	set_sat_c_up_to_date ()
	Sets `status` to express that `sat_c` is up-to-date. More...

void	set_sat_g_up_to_date ()
	Sets `status` to express that `sat_g` is up-to-date. More...

State Flag Cleaners: Clear Only the Specified Flag
void	clear_empty ()
	Clears the `status` flag indicating that the polyhedron is empty. More...

void	clear_constraints_up_to_date ()
	Sets `status` to express that constraints are no longer up-to-date. More...

void	clear_generators_up_to_date ()
	Sets `status` to express that generators are no longer up-to-date. More...

void	clear_constraints_minimized ()
	Sets `status` to express that constraints are no longer minimized. More...

void	clear_generators_minimized ()
	Sets `status` to express that generators are no longer minimized. More...

void	clear_pending_constraints ()
	Sets `status` to express that there are no longer pending constraints. More...

void	clear_pending_generators ()
	Sets `status` to express that there are no longer pending generators. More...

void	clear_sat_c_up_to_date ()
	Sets `status` to express that `sat_c` is no longer up-to-date. More...

void	clear_sat_g_up_to_date ()
	Sets `status` to express that `sat_g` is no longer up-to-date. More...

The Handling of Pending Rows
bool	process_pending () const
	Processes the pending rows of either description of the polyhedron and obtains a minimized polyhedron. More...

bool	process_pending_constraints () const
	Processes the pending constraints and obtains a minimized polyhedron. More...

void	process_pending_generators () const
	Processes the pending generators and obtains a minimized polyhedron. More...

void	remove_pending_to_obtain_constraints () const
	Lazily integrates the pending descriptions of the polyhedron to obtain a constraint system without pending rows. More...

bool	remove_pending_to_obtain_generators () const
	Lazily integrates the pending descriptions of the polyhedron to obtain a generator system without pending rows. More...

Updating and Sorting Matrices
void	update_constraints () const
	Updates constraints starting from generators and minimizes them. More...

bool	update_generators () const
	Updates generators starting from constraints and minimizes them. More...

void	update_sat_c () const
	Updates `sat_c` using the updated constraints and generators. More...

void	update_sat_g () const
	Updates `sat_g` using the updated constraints and generators. More...

void	obtain_sorted_constraints () const
	Sorts the matrix of constraints keeping status consistency. More...

void	obtain_sorted_generators () const
	Sorts the matrix of generators keeping status consistency. More...

void	obtain_sorted_constraints_with_sat_c () const
	Sorts the matrix of constraints and updates `sat_c`. More...

void	obtain_sorted_generators_with_sat_g () const
	Sorts the matrix of generators and updates `sat_g`. More...

Weak and Strong Minimization of Descriptions
bool	minimize () const
	Applies (weak) minimization to both the constraints and generators. More...

bool	strongly_minimize_constraints () const
	Applies strong minimization to the constraints of an NNC polyhedron. More...

bool	strongly_minimize_generators () const
	Applies strong minimization to the generators of an NNC polyhedron. More...

Constraint_System	simplified_constraints () const
	If constraints are up-to-date, obtain a simplified copy of them. More...

Static Private Member Functions
template<typename Linear_System1 , typename Linear_System2 >
static void	add_space_dimensions (Linear_System1 &sys1, Linear_System2 &sys2, Bit_Matrix &sat1, Bit_Matrix &sat2, dimension_type add_dim)
	Adds new space dimensions to the given linear systems. More...

Minimization-Related Static Member Functions
template<typename Source_Linear_System , typename Dest_Linear_System >
static bool	minimize (bool con_to_gen, Source_Linear_System &source, Dest_Linear_System &dest, Bit_Matrix &sat)
	Builds and simplifies constraints from generators (or vice versa). More...

template<typename Source_Linear_System1 , typename Source_Linear_System2 , typename Dest_Linear_System >
static bool	add_and_minimize (bool con_to_gen, Source_Linear_System1 &source1, Dest_Linear_System &dest, Bit_Matrix &sat, const Source_Linear_System2 &source2)
	Adds given constraints and builds minimized corresponding generators or vice versa. More...

template<typename Source_Linear_System , typename Dest_Linear_System >
static bool	add_and_minimize (bool con_to_gen, Source_Linear_System &source, Dest_Linear_System &dest, Bit_Matrix &sat)
	Adds given constraints and builds minimized corresponding generators or vice versa. The given constraints are in `source`. More...

template<typename Source_Linear_System , typename Dest_Linear_System >
static dimension_type	conversion (Source_Linear_System &source, dimension_type start, Dest_Linear_System &dest, Bit_Matrix &sat, dimension_type num_lines_or_equalities)
	Performs the conversion from constraints to generators and vice versa. More...

template<typename Linear_System1 >
static dimension_type	simplify (Linear_System1 &sys, Bit_Matrix &sat)
	Uses Gauss' elimination method to simplify the result of `conversion()`. More...

Private Attributes
Constraint_System	con_sys
	The system of constraints. More...

Generator_System	gen_sys
	The system of generators. More...

Bit_Matrix	sat_c
	The saturation matrix having constraints on its columns. More...

Bit_Matrix	sat_g
	The saturation matrix having generators on its columns. More...

Status	status
	The status flags to keep track of the polyhedron's internal state. More...

dimension_type	space_dim
	The number of dimensions of the enclosing vector space. More...

Static Private Attributes
static const Representation	default_con_sys_repr = DENSE

static const Representation	default_gen_sys_repr = DENSE

static dimension_type *	simplify_num_saturators_p = 0
	Pointer to an array used by simplify(). More...

static size_t	simplify_num_saturators_size = 0
	Dimension of an array used by simplify(). More...

Friends
template<typename Interval >
class	Parma_Polyhedra_Library::Box

template<typename T >
class	Parma_Polyhedra_Library::BD_Shape

template<typename T >
class	Parma_Polyhedra_Library::Octagonal_Shape

class	Parma_Polyhedra_Library::Grid

class	Parma_Polyhedra_Library::BHRZ03_Certificate

class	Parma_Polyhedra_Library::H79_Certificate

bool	operator== (const Polyhedron &x, const Polyhedron &y)

bool	Parma_Polyhedra_Library::Interfaces::is_necessarily_closed_for_interfaces (const Polyhedron &)

Related Functions
(Note that these are not member functions.)
template<typename PH >
bool	poly_hull_assign_if_exact (PH &p, const PH &q)
	If the poly-hull of `p` and `q` is exact it is assigned to `p` and `true` is returned, otherwise `false` is returned. More...

template<typename PH >
bool	poly_hull_assign_if_exact (PH &p, const PH &q)

std::ostream &	operator<< (std::ostream &s, const Polyhedron &ph)
	Output operator. More...

void	swap (Polyhedron &x, Polyhedron &y)
	Swaps `x` with `y`. More...

bool	operator== (const Polyhedron &x, const Polyhedron &y)
	Returns `true` if and only if `x` and `y` are the same polyhedron. More...

bool	operator!= (const Polyhedron &x, const Polyhedron &y)
	Returns `true` if and only if `x` and `y` are different polyhedra. More...

void	swap (Polyhedron &x, Polyhedron &y)

bool	operator!= (const Polyhedron &x, const Polyhedron &y)

bool	operator== (const Polyhedron &x, const Polyhedron &y)

std::ostream &	operator<< (std::ostream &s, const Polyhedron &ph)

Widening- and Extrapolation-Related Functions
void	select_CH78_constraints (const Polyhedron &y, Constraint_System &cs_selection) const
	Copies to `cs_selection` the constraints of `y` corresponding to the definition of the CH78-widening of `*this` and `y`. More...

void	select_H79_constraints (const Polyhedron &y, Constraint_System &cs_selected, Constraint_System &cs_not_selected) const
	Splits the constraints of `x' into two subsets, depending on whether or not they are selected to compute the H79-widening of `*this` and `y`. More...

bool	BHRZ03_combining_constraints (const Polyhedron &y, const BHRZ03_Certificate &y_cert, const Polyhedron &H79, const Constraint_System &x_minus_H79_cs)

bool	BHRZ03_evolving_points (const Polyhedron &y, const BHRZ03_Certificate &y_cert, const Polyhedron &H79)

bool	BHRZ03_evolving_rays (const Polyhedron &y, const BHRZ03_Certificate &y_cert, const Polyhedron &H79)

static void	modify_according_to_evolution (Linear_Expression &ray, const Linear_Expression &x, const Linear_Expression &y)

Exception Throwers
void	throw_invalid_argument (const char method, const char reason) const

void	throw_topology_incompatible (const char method, const char ph_name, const Polyhedron &ph) const

void	throw_topology_incompatible (const char method, const char c_name, const Constraint &c) const

void	throw_topology_incompatible (const char method, const char g_name, const Generator &g) const

void	throw_topology_incompatible (const char method, const char cs_name, const Constraint_System &cs) const

void	throw_topology_incompatible (const char method, const char gs_name, const Generator_System &gs) const

void	throw_dimension_incompatible (const char method, const char other_name, dimension_type other_dim) const

void	throw_dimension_incompatible (const char method, const char ph_name, const Polyhedron &ph) const

void	throw_dimension_incompatible (const char method, const char le_name, const Linear_Expression &le) const

void	throw_dimension_incompatible (const char method, const char c_name, const Constraint &c) const

void	throw_dimension_incompatible (const char method, const char g_name, const Generator &g) const

void	throw_dimension_incompatible (const char method, const char cg_name, const Congruence &cg) const

void	throw_dimension_incompatible (const char method, const char cs_name, const Constraint_System &cs) const

void	throw_dimension_incompatible (const char method, const char gs_name, const Generator_System &gs) const

void	throw_dimension_incompatible (const char method, const char cgs_name, const Congruence_System &cgs) const

template<typename C >
void	throw_dimension_incompatible (const char method, const char lf_name, const Linear_Form< C > &lf) const

void	throw_dimension_incompatible (const char method, const char var_name, Variable var) const

void	throw_dimension_incompatible (const char *method, dimension_type required_space_dim) const

void	throw_invalid_generator (const char method, const char g_name) const

void	throw_invalid_generators (const char method, const char gs_name) const

static dimension_type	check_space_dimension_overflow (dimension_type dim, dimension_type max, const Topology topol, const char method, const char reason)

static dimension_type	check_space_dimension_overflow (dimension_type dim, const Topology topol, const char method, const char reason)

template<typename Object >
static Object &	check_obj_space_dimension_overflow (Object &input, Topology topol, const char method, const char reason)

Detailed Description

The base class for convex polyhedra.

An object of the class Polyhedron represents a convex polyhedron in the vector space $\Rset^n$ .

A polyhedron can be specified as either a finite system of constraints or a finite system of generators (see Section Representations of Convex Polyhedra) and it is always possible to obtain either representation. That is, if we know the system of constraints, we can obtain from this the system of generators that define the same polyhedron and vice versa. These systems can contain redundant members: in this case we say that they are not in the minimal form.

Two key attributes of any polyhedron are its topological kind (recording whether it is a C_Polyhedron or an NNC_Polyhedron object) and its space dimension (the dimension $n \in \Nset$ of the enclosing vector space):

all polyhedra, the empty ones included, are endowed with a specific topology and space dimension;
most operations working on a polyhedron and another object (i.e., another polyhedron, a constraint or generator, a set of variables, etc.) will throw an exception if the polyhedron and the object are not both topology-compatible and dimension-compatible (see Section Representations of Convex Polyhedra);
the topology of a polyhedron cannot be changed; rather, there are constructors for each of the two derived classes that will build a new polyhedron with the topology of that class from another polyhedron from either class and any topology;
the only ways in which the space dimension of a polyhedron can be changed are:
- explicit calls to operators provided for that purpose;
- standard copy, assignment and swap operators.

Note that four different polyhedra can be defined on the zero-dimension space: the empty polyhedron, either closed or NNC, and the universe polyhedron $R^0$ , again either closed or NNC.

: In all the examples it is assumed that variables x and y are defined (where they are used) as follows:
Variable x(0);

Variable y(1);

Example 1: The following code builds a polyhedron corresponding to a square in $\Rset^2$ , given as a system of constraints:
Constraint_System cs;

cs.insert(x >= 0);

cs.insert(x <= 3);

cs.insert(y >= 0);

cs.insert(y <= 3);

C_Polyhedron ph(cs);

The following code builds the same polyhedron as above, but starting from a system of generators specifying the four vertices of the square:
Generator_System gs;

gs.insert(point(0*x + 0*y));

gs.insert(point(0*x + 3*y));

gs.insert(point(3*x + 0*y));

gs.insert(point(3*x + 3*y));

C_Polyhedron ph(gs);

Example 2: The following code builds an unbounded polyhedron corresponding to a half-strip in $\Rset^2$ , given as a system of constraints:
Constraint_System cs;

cs.insert(x >= 0);

cs.insert(x - y <= 0);

cs.insert(x - y + 1 >= 0);

C_Polyhedron ph(cs);

The following code builds the same polyhedron as above, but starting from the system of generators specifying the two vertices of the polyhedron and one ray:
Generator_System gs;

gs.insert(point(0*x + 0*y));

gs.insert(point(0*x + y));

gs.insert(ray(x - y));

C_Polyhedron ph(gs);

Example 3: The following code builds the polyhedron corresponding to a half-plane by adding a single constraint to the universe polyhedron in $\Rset^2$ :
C_Polyhedron ph(2);

ph.add_constraint(y >= 0);

The following code builds the same polyhedron as above, but starting from the empty polyhedron in the space $\Rset^2$ and inserting the appropriate generators (a point, a ray and a line).
C_Polyhedron ph(2, EMPTY);

ph.add_generator(point(0*x + 0*y));

ph.add_generator(ray(y));

ph.add_generator(line(x));

Note that, although the above polyhedron has no vertices, we must add one point, because otherwise the result of the Minkowski's sum would be an empty polyhedron. To avoid subtle errors related to the minimization process, it is required that the first generator inserted in an empty polyhedron is a point (otherwise, an exception is thrown).

Example 4: The following code shows the use of the function add_space_dimensions_and_embed:
C_Polyhedron ph(1);

ph.add_constraint(x == 2);

ph.add_space_dimensions_and_embed(1);

We build the universe polyhedron in the 1-dimension space $\Rset$ . Then we add a single equality constraint, thus obtaining the polyhedron corresponding to the singleton set $\{ 2 \} \sseq \Rset$ . After the last line of code, the resulting polyhedron is
$\bigl\{\, (2, y)^\transpose \in \Rset^2 \bigm| y \in \Rset \,\bigr\}.$

Example 5: The following code shows the use of the function add_space_dimensions_and_project:
C_Polyhedron ph(1);

ph.add_constraint(x == 2);

ph.add_space_dimensions_and_project(1);

The first two lines of code are the same as in Example 4 for add_space_dimensions_and_embed. After the last line of code, the resulting polyhedron is the singleton set $\bigl\{ (2, 0)^\transpose \bigr\} \sseq \Rset^2$ .

Example 6: The following code shows the use of the function affine_image:
C_Polyhedron ph(2, EMPTY);

ph.add_generator(point(0*x + 0*y));

ph.add_generator(point(0*x + 3*y));

ph.add_generator(point(3*x + 0*y));

ph.add_generator(point(3*x + 3*y));

Linear_Expression expr = x + 4;

ph.affine_image(x, expr);

In this example the starting polyhedron is a square in $\Rset^2$ , the considered variable is and the affine expression is . The resulting polyhedron is the same square translated to the right. Moreover, if the affine transformation for the same variable x is :
Linear_Expression expr = x + y;

the resulting polyhedron is a parallelogram with the height equal to the side of the square and the oblique sides parallel to the line . Instead, if we do not use an invertible transformation for the same variable; for example, the affine expression :
Linear_Expression expr = y;

the resulting polyhedron is a diagonal of the square.

Example 7: The following code shows the use of the function affine_preimage:
C_Polyhedron ph(2);

ph.add_constraint(x >= 0);

ph.add_constraint(x <= 3);

ph.add_constraint(y >= 0);

ph.add_constraint(y <= 3);

Linear_Expression expr = x + 4;

ph.affine_preimage(x, expr);

In this example the starting polyhedron, var and the affine expression and the denominator are the same as in Example 6, while the resulting polyhedron is again the same square, but translated to the left. Moreover, if the affine transformation for x is
Linear_Expression expr = x + y;

the resulting polyhedron is a parallelogram with the height equal to the side of the square and the oblique sides parallel to the line . Instead, if we do not use an invertible transformation for the same variable x, for example, the affine expression :
Linear_Expression expr = y;

the resulting polyhedron is a line that corresponds to the axis.

Example 8: For this example we use also the variables:
Variable z(2);

Variable w(3);

The following code shows the use of the function remove_space_dimensions:
Generator_System gs;

gs.insert(point(3*x + y + 0*z + 2*w));

C_Polyhedron ph(gs);

Variables_Set vars;

vars.insert(y);

vars.insert(z);

ph.remove_space_dimensions(vars);

The starting polyhedron is the singleton set $\bigl\{ (3, 1, 0, 2)^\transpose \bigr\} \sseq \Rset^4$ , while the resulting polyhedron is $\bigl\{ (3, 2)^\transpose \bigr\} \sseq \Rset^2$ . Be careful when removing space dimensions incrementally: since dimensions are automatically renamed after each application of the remove_space_dimensions operator, unexpected results can be obtained. For instance, by using the following code we would obtain a different result:
set<Variable> vars1;

vars1.insert(y);

ph.remove_space_dimensions(vars1);

set<Variable> vars2;

vars2.insert(z);

ph.remove_space_dimensions(vars2);

In this case, the result is the polyhedron $\bigl\{(3, 0)^\transpose \bigr\} \sseq \Rset^2$ : when removing the set of dimensions vars2 we are actually removing variable of the original polyhedron. For the same reason, the operator remove_space_dimensions is not idempotent: removing twice the same non-empty set of dimensions is never the same as removing them just once.

Definition at line 369 of file Polyhedron_defs.hh.

Member Typedef Documentation

typedef Coefficient Parma_Polyhedra_Library::Polyhedron::coefficient_type

The numeric type of coefficients.

Definition at line 372 of file Polyhedron_defs.hh.

Constructor & Destructor Documentation

Parma_Polyhedra_Library::Polyhedron::Polyhedron	(	Topology	topol,
		dimension_type	num_dimensions,
		Degenerate_Element	kind
	)

protected

Builds a polyhedron having the specified properties.

Parameters

topol	The topology of the polyhedron;
num_dimensions	The number of dimensions of the vector space enclosing the polyhedron;
kind	Specifies whether the universe or the empty polyhedron has to be built.

Definition at line 52 of file Polyhedron_nonpublic.cc.

References Parma_Polyhedra_Library::Constraint_System::add_low_level_constraints(), Parma_Polyhedra_Library::Constraint_System::adjust_topology_and_space_dimension(), con_sys, Parma_Polyhedra_Library::EMPTY, max_space_dimension(), OK(), set_constraints_minimized(), Parma_Polyhedra_Library::Polyhedron::Status::set_empty(), space_dim, and status.

Referenced by affine_form_image().

   : con_sys(topol, default_con_sys_repr),
     gen_sys(topol, default_gen_sys_repr),
     sat_c(),
     sat_g() {
   // Protecting against space dimension overflow is up to the caller.
   PPL_ASSERT(num_dimensions <= max_space_dimension());
 
   if (kind == EMPTY) {
     status.set_empty();
   }
   else if (num_dimensions > 0) {
     con_sys.add_low_level_constraints();
     con_sys.adjust_topology_and_space_dimension(topol, num_dimensions);
     set_constraints_minimized();
   }
   space_dim = num_dimensions;
   PPL_ASSERT_HEAVY(OK());
 }

Parma_Polyhedra_Library::Polyhedron::Polyhedron	(	const Polyhedron &	y,
		Complexity_Class	complexity = `ANY_COMPLEXITY`
	)

protected

Ordinary copy constructor.

The complexity argument is ignored.

Definition at line 74 of file Polyhedron_nonpublic.cc.

References Parma_Polyhedra_Library::Generator_System::assign_with_pending(), Parma_Polyhedra_Library::Constraint_System::assign_with_pending(), con_sys, constraints_are_up_to_date(), gen_sys, generators_are_up_to_date(), sat_c, sat_c_is_up_to_date(), sat_g, sat_g_is_up_to_date(), and topology().

   : con_sys(y.topology(), default_con_sys_repr),
     gen_sys(y.topology(), default_gen_sys_repr),
     status(y.status),
     space_dim(y.space_dim) {
   // Being a protected method, we simply assert that topologies do match.
   PPL_ASSERT(topology() == y.topology());
   if (y.constraints_are_up_to_date()) {
     con_sys.assign_with_pending(y.con_sys);
   }
   if (y.generators_are_up_to_date()) {
     gen_sys.assign_with_pending(y.gen_sys);
   }
   if (y.sat_c_is_up_to_date()) {
     sat_c = y.sat_c;
   }
   if (y.sat_g_is_up_to_date()) {
     sat_g = y.sat_g;
   }
 }

Parma_Polyhedra_Library::Polyhedron::Polyhedron	(	Topology	topol,
		const Constraint_System &	cs
	)

protected

Builds a polyhedron from a system of constraints.

The polyhedron inherits the space dimension of the constraint system.

Parameters

topol	The topology of the polyhedron;
cs	The system of constraints defining the polyhedron.

Exceptions

std::invalid_argument Thrown if the topology of cs is incompatible with topol.

Definition at line 95 of file Polyhedron_nonpublic.cc.

References Parma_Polyhedra_Library::Constraint_System::add_low_level_constraints(), con_sys, max_space_dimension(), Parma_Polyhedra_Library::NECESSARILY_CLOSED, Parma_Polyhedra_Library::Constraint_System::num_pending_rows(), OK(), set_constraints_up_to_date(), set_empty(), Parma_Polyhedra_Library::Constraint_System::set_sorted(), space_dim, Parma_Polyhedra_Library::Constraint_System::space_dimension(), swap(), Parma_Polyhedra_Library::swap(), throw_topology_incompatible(), and Parma_Polyhedra_Library::Constraint_System::unset_pending_rows().

   : con_sys(topol, default_con_sys_repr),
     gen_sys(topol, default_gen_sys_repr),
     sat_c(),
     sat_g() {
   // Protecting against space dimension overflow is up to the caller.
   PPL_ASSERT(cs.space_dimension() <= max_space_dimension());
 
   // TODO: this implementation is just an executable specification.
   Constraint_System cs_copy = cs;
 
   // Try to adapt `cs_copy' to the required topology.
   const dimension_type cs_copy_space_dim = cs_copy.space_dimension();
   if (!cs_copy.adjust_topology_and_space_dimension(topol, cs_copy_space_dim)) {
     throw_topology_incompatible((topol == NECESSARILY_CLOSED)
                                 ? "C_Polyhedron(cs)"
                                 : "NNC_Polyhedron(cs)", "cs", cs_copy);
   }
   // Set the space dimension.
   space_dim = cs_copy_space_dim;
 
   if (space_dim > 0) {
     // Stealing the rows from `cs_copy'.
     using std::swap;
     swap(con_sys, cs_copy);
     if (con_sys.num_pending_rows() > 0) {
       // Even though `cs_copy' has pending constraints, since the
       // generators of the polyhedron are not up-to-date, the
       // polyhedron cannot have pending constraints. By integrating
       // the pending part of `con_sys' we may loose sortedness.
       con_sys.set_sorted(false);
       con_sys.unset_pending_rows();
     }
     con_sys.add_low_level_constraints();
     set_constraints_up_to_date();
   }
   else {
     // Here `space_dim == 0'.
     // See if an inconsistent constraint has been passed.
     for (dimension_type i = cs_copy.num_rows(); i-- > 0; ) {
       if (cs_copy[i].is_inconsistent()) {
         // Inconsistent constraint found: the polyhedron is empty.
         set_empty();
         break;
       }
     }
   }
   PPL_ASSERT_HEAVY(OK());
 }

Parma_Polyhedra_Library::Polyhedron::Polyhedron	(	Topology	topol,
		Constraint_System &	cs,
		Recycle_Input	dummy
	)

protected

Builds a polyhedron recycling a system of constraints.

The polyhedron inherits the space dimension of the constraint system.

Parameters

topol	The topology of the polyhedron;
cs	The system of constraints defining the polyhedron. It is not declared `const` because its data-structures may be recycled to build the polyhedron.
dummy	A dummy tag to syntactically differentiate this one from the other constructors.

Exceptions

std::invalid_argument Thrown if the topology of cs is incompatible with topol.

Definition at line 145 of file Polyhedron_nonpublic.cc.

   : con_sys(topol, default_con_sys_repr),
     gen_sys(topol, default_gen_sys_repr),
     sat_c(),
     sat_g() {
   // Protecting against space dimension overflow is up to the caller.
   PPL_ASSERT(cs.space_dimension() <= max_space_dimension());
 
   // Try to adapt `cs' to the required topology.
   const dimension_type cs_space_dim = cs.space_dimension();
   if (!cs.adjust_topology_and_space_dimension(topol, cs_space_dim)) {
     throw_topology_incompatible((topol == NECESSARILY_CLOSED)
                                 ? "C_Polyhedron(cs, recycle)"
                                 : "NNC_Polyhedron(cs, recycle)", "cs", cs);
   }
 
   // Set the space dimension.
   space_dim = cs_space_dim;
 
   if (space_dim > 0) {
     // Stealing the rows from `cs'.
     swap(con_sys, cs);
     if (con_sys.num_pending_rows() > 0) {
       // Even though `cs' has pending constraints, since the generators
       // of the polyhedron are not up-to-date, the polyhedron cannot
       // have pending constraints. By integrating the pending part
       // of `con_sys' we may loose sortedness.
       con_sys.unset_pending_rows();
       con_sys.set_sorted(false);
     }
     con_sys.add_low_level_constraints();
     set_constraints_up_to_date();
   }
   else {
     // Here `space_dim == 0'.
 
     // See if an inconsistent constraint has been passed.
     for (dimension_type i = cs.num_rows(); i-- > 0; ) {
       if (cs[i].is_inconsistent()) {
         // Inconsistent constraint found: the polyhedron is empty.
         set_empty();
         break;
       }
     }
   }
   PPL_ASSERT_HEAVY(OK());
 }

Parma_Polyhedra_Library::Polyhedron::Polyhedron	(	Topology	topol,
		const Generator_System &	gs
	)

protected

Builds a polyhedron from a system of generators.

The polyhedron inherits the space dimension of the generator system.

Parameters

topol	The topology of the polyhedron;
gs	The system of generators defining the polyhedron.

Exceptions

std::invalid_argument Thrown if the topology of gs is incompatible with topol, or if the system of generators is not empty but has no points.

Definition at line 195 of file Polyhedron_nonpublic.cc.

   : con_sys(topol, default_con_sys_repr),
     gen_sys(topol, default_gen_sys_repr),
     sat_c(),
     sat_g() {
   // Protecting against space dimension overflow is up to the caller.
   PPL_ASSERT(gs.space_dimension() <= max_space_dimension());
 
   // An empty set of generators defines the empty polyhedron.
   if (gs.has_no_rows()) {
     space_dim = gs.space_dimension();
     status.set_empty();
     PPL_ASSERT_HEAVY(OK());
     return;
   }
 
   // Non-empty valid generator systems have a supporting point, at least.
   if (!gs.has_points()) {
     throw_invalid_generators((topol == NECESSARILY_CLOSED)
                              ? "C_Polyhedron(gs)"
                              : "NNC_Polyhedron(gs)", "gs");
   }
   // TODO: this implementation is just an executable specification.
   Generator_System gs_copy = gs;
 
   const dimension_type gs_copy_space_dim = gs_copy.space_dimension();
   // Try to adapt `gs_copy' to the required topology.
   if (!gs_copy.adjust_topology_and_space_dimension(topol, gs_copy_space_dim)) {
     throw_topology_incompatible((topol == NECESSARILY_CLOSED)
                                 ? "C_Polyhedron(gs)"
                                 : "NNC_Polyhedron(gs)", "gs", gs_copy);
   }
 
   if (gs_copy_space_dim > 0) {
     // Stealing the rows from `gs_copy'.
     using std::swap;
     swap(gen_sys, gs_copy);
     // In a generator system describing a NNC polyhedron,
     // for each point we must also have the corresponding closure point.
     if (topol == NOT_NECESSARILY_CLOSED) {
       gen_sys.add_corresponding_closure_points();
     }
     if (gen_sys.num_pending_rows() > 0) {
       // Even though `gs_copy' has pending generators, since the
       // constraints of the polyhedron are not up-to-date, the
       // polyhedron cannot have pending generators. By integrating the
       // pending part of `gen_sys' we may lose sortedness.
       gen_sys.set_sorted(false);
       gen_sys.unset_pending_rows();
     }
     // Generators are now up-to-date.
     set_generators_up_to_date();
 
     // Set the space dimension.
     space_dim = gs_copy_space_dim;
     PPL_ASSERT_HEAVY(OK());
     return;
   }
 
   // Here `gs_copy.num_rows > 0' and `gs_copy_space_dim == 0':
   // we already checked for both the topology-compatibility
   // and the supporting point.
   space_dim = 0;
   PPL_ASSERT_HEAVY(OK());
 }

Parma_Polyhedra_Library::Polyhedron::Polyhedron	(	Topology	topol,
		Generator_System &	gs,
		Recycle_Input	dummy
	)

protected

Builds a polyhedron recycling a system of generators.

The polyhedron inherits the space dimension of the generator system.

Parameters

topol	The topology of the polyhedron;
gs	The system of generators defining the polyhedron. It is not declared `const` because its data-structures may be recycled to build the polyhedron.
dummy	A dummy tag to syntactically differentiate this one from the other constructors.

Exceptions

std::invalid_argument Thrown if the topology of gs is incompatible with topol, or if the system of generators is not empty but has no points.

Definition at line 261 of file Polyhedron_nonpublic.cc.

   : con_sys(topol, default_con_sys_repr),
     gen_sys(topol, default_gen_sys_repr),
     sat_c(),
     sat_g() {
   // Protecting against space dimension overflow is up to the caller.
   PPL_ASSERT(gs.space_dimension() <= max_space_dimension());
 
   // An empty set of generators defines the empty polyhedron.
   if (gs.has_no_rows()) {
     space_dim = gs.space_dimension();
     status.set_empty();
     PPL_ASSERT_HEAVY(OK());
     return;
   }
 
   // Non-empty valid generator systems have a supporting point, at least.
   if (!gs.has_points()) {
     throw_invalid_generators((topol == NECESSARILY_CLOSED)
                              ? "C_Polyhedron(gs, recycle)"
                              : "NNC_Polyhedron(gs, recycle)", "gs");
   }
 
   const dimension_type gs_space_dim = gs.space_dimension();
   // Try to adapt `gs' to the required topology.
   if (!gs.adjust_topology_and_space_dimension(topol, gs_space_dim)) {
     throw_topology_incompatible((topol == NECESSARILY_CLOSED)
                                 ? "C_Polyhedron(gs, recycle)"
                                 : "NNC_Polyhedron(gs, recycle)", "gs", gs);
   }
 
   if (gs_space_dim > 0) {
     // Stealing the rows from `gs'.
     swap(gen_sys, gs);
     // In a generator system describing a NNC polyhedron,
     // for each point we must also have the corresponding closure point.
     if (topol == NOT_NECESSARILY_CLOSED) {
       gen_sys.add_corresponding_closure_points();
     }
     if (gen_sys.num_pending_rows() > 0) {
       // Even though `gs' has pending generators, since the constraints
       // of the polyhedron are not up-to-date, the polyhedron cannot
       // have pending generators. By integrating the pending part
       // of `gen_sys' we may loose sortedness.
       gen_sys.set_sorted(false);
       gen_sys.unset_pending_rows();
     }
     // Generators are now up-to-date.
     set_generators_up_to_date();
 
     // Set the space dimension.
     space_dim = gs_space_dim;
     PPL_ASSERT_HEAVY(OK());
     return;
   }
 
   // Here `gs.num_rows > 0' and `gs_space_dim == 0':
   // we already checked for both the topology-compatibility
   // and the supporting point.
   space_dim = 0;
   PPL_ASSERT_HEAVY(OK());
 }

template<typename Interval >

Parma_Polyhedra_Library::Polyhedron::Polyhedron	(	Topology	topol,
		const Box< Interval > &	box,
		Complexity_Class	complexity = `ANY_COMPLEXITY`
	)

protected

Builds a polyhedron from a box.

This will use an algorithm whose complexity is polynomial and build the smallest polyhedron with topology topol containing box.

Parameters

topol	The topology of the polyhedron;
box	The box representing the polyhedron to be built;
complexity	This argument is ignored.

Definition at line 39 of file Polyhedron_templates.hh.

   : con_sys(topol, default_con_sys_repr),
     gen_sys(topol, default_gen_sys_repr),
     sat_c(),
     sat_g() {
   // Initialize the space dimension as indicated by the box.
   space_dim = box.space_dimension();
 
   // Check for emptiness.
   if (box.is_empty()) {
     set_empty();
     return;
   }
 
   // Zero-dim universe polyhedron.
   if (space_dim == 0) {
     set_zero_dim_univ();
     return;
   }
 
   // Properly set the space dimension of `con_sys'.
   con_sys.set_space_dimension(space_dim);
 
   PPL_DIRTY_TEMP_COEFFICIENT(l_n);
   PPL_DIRTY_TEMP_COEFFICIENT(l_d);
   PPL_DIRTY_TEMP_COEFFICIENT(u_n);
   PPL_DIRTY_TEMP_COEFFICIENT(u_d);
 
   if (topol == NECESSARILY_CLOSED) {
     for (dimension_type k = space_dim; k-- > 0; ) {
       const Variable v_k = Variable(k);
       // See if we have a valid lower bound.
       bool l_closed = false;
       bool l_bounded = box.has_lower_bound(v_k, l_n, l_d, l_closed);
       // See if we have a valid upper bound.
       bool u_closed = false;
       bool u_bounded = box.has_upper_bound(v_k, u_n, u_d, u_closed);
 
       // See if we have an implicit equality constraint.
       if (l_bounded && u_bounded
           && l_closed && u_closed
           && l_n == u_n && l_d == u_d) {
         // Add the constraint `l_d*v_k == l_n'.
         con_sys.insert(l_d * v_k == l_n);
       }
       else {
         if (l_bounded) {
           // Add the constraint `l_d*v_k >= l_n'.
           con_sys.insert(l_d * v_k >= l_n);
         }
         if (u_bounded) {
           // Add the constraint `u_d*v_k <= u_n'.
           con_sys.insert(u_d * v_k <= u_n);
         }
       }
     }
   }
   else {
     // topol == NOT_NECESSARILY_CLOSED
     for (dimension_type k = space_dim; k-- > 0; ) {
       const Variable v_k = Variable(k);
       // See if we have a valid lower bound.
       bool l_closed = false;
       bool l_bounded = box.has_lower_bound(v_k, l_n, l_d, l_closed);
       // See if we have a valid upper bound.
       bool u_closed = false;
       bool u_bounded = box.has_upper_bound(v_k, u_n, u_d, u_closed);
 
       // See if we have an implicit equality constraint.
       if (l_bounded && u_bounded
           && l_closed && u_closed
           && l_n == u_n && l_d == u_d) {
         // Add the constraint `l_d*v_k == l_n'.
         con_sys.insert(l_d * v_k == l_n);
       }
       else {
         // Check if a lower bound constraint is required.
         if (l_bounded) {
           if (l_closed) {
             // Add the constraint `l_d*v_k >= l_n'.
             con_sys.insert(l_d * v_k >= l_n);
           }
           else {
             // Add the constraint `l_d*v_k > l_n'.
             con_sys.insert(l_d * v_k > l_n);
           }
         }
         // Check if an upper bound constraint is required.
         if (u_bounded) {
           if (u_closed) {
             // Add the constraint `u_d*v_k <= u_n'.
             con_sys.insert(u_d * v_k <= u_n);
           }
           else {
             // Add the constraint `u_d*v_k < u_n'.
             con_sys.insert(u_d * v_k < u_n);
           }
         }
       }
     }
   }
 
   // Adding the low-level constraints.
   con_sys.add_low_level_constraints();
 
   // Constraints are up-to-date.
   set_constraints_up_to_date();
   PPL_ASSERT_HEAVY(OK());
 }

Parma_Polyhedra_Library::Polyhedron::~Polyhedron ( )

inline

Destructor.

Definition at line 96 of file Polyhedron_inlines.hh.

96 {

97 }

Member Function Documentation

template<typename Source_Linear_System1 , typename Source_Linear_System2 , typename Dest_Linear_System >

bool Parma_Polyhedra_Library::Polyhedron::add_and_minimize	(	bool	con_to_gen,
		Source_Linear_System1 &	source1,
		Dest_Linear_System &	dest,
		Bit_Matrix &	sat,
		const Source_Linear_System2 &	source2
	)

staticprivate

Adds given constraints and builds minimized corresponding generators or vice versa.

Returns: true if the obtained polyhedron is empty, false otherwise.

Parameters

con_to_gen	`true` if `source1` and `source2` are system of constraints, `false` otherwise;
source1	The first element of the given DD pair;
dest	The second element of the given DD pair;
sat	The saturation matrix that bind `source1` to `dest`;
source2	The new system of generators or constraints.

It is assumed that source1 and source2 are sorted and have no pending rows. It is also assumed that dest has no pending rows. On entry, the rows of sat are indexed by the rows of dest and its columns are indexed by the rows of source1. On exit, the rows of sat are indexed by the rows of dest and its columns are indexed by the rows of the system obtained by merging source1 and source2.

Let us suppose we want to add some constraints to a given system of constraints source1. This method, given a minimized double description pair (source1, dest) and a system of new constraints source2, modifies source1 by adding to it the constraints of source2 that are not in source1. Then, by invoking add_and_minimize(bool, Linear_System_Class&, Linear_System_Class&, Bit_Matrix&), processes the added constraints obtaining a new DD pair.

This method treats also the dual case, i.e., adding new generators to a previous system of generators. In this case source1 contains the old generators, source2 the new ones and dest is the system of constraints in the given minimized DD pair.

Since source2 contains the constraints (or the generators) that will be added to source1, it is constant: it will not be modified.

Definition at line 267 of file Polyhedron_minimize_templates.hh.

References Parma_Polyhedra_Library::cmp(), and Parma_Polyhedra_Library::compare().

                                                                    {
   // `source1' and `source2' cannot be empty.
   PPL_ASSERT(!source1.has_no_rows() && !source2.has_no_rows());
   // `source1' and `source2' must have the same number of columns
   // to be merged.
   PPL_ASSERT(source1.num_columns() == source2.num_columns());
   // `source1' and `source2' are fully sorted.
   PPL_ASSERT(source1.is_sorted() && source1.num_pending_rows() == 0);
   PPL_ASSERT(source2.is_sorted() && source2.num_pending_rows() == 0);
   PPL_ASSERT(dest.num_pending_rows() == 0);
 
   const dimension_type old_source1_num_rows = source1.num_rows();
   // `k1' and `k2' run through the rows of `source1' and `source2', resp.
   dimension_type k1 = 0;
   dimension_type k2 = 0;
   dimension_type source2_num_rows = source2.num_rows();
   while (k1 < old_source1_num_rows && k2 < source2_num_rows) {
     // Add to `source1' the constraints from `source2', as pending rows.
     // We exploit the property that initially both `source1' and `source2'
     // are sorted and index `k1' only scans the non-pending rows of `source1',
     // so that it is not influenced by the pending rows appended to it.
     // This way no duplicate (i.e., trivially redundant) constraint
     // is introduced in `source1'.
     const int cmp = compare(source1[k1], source2[k2]);
     if (cmp == 0) {
       // We found the same row: there is no need to add `source2[k2]'.
       ++k2;
       // By sortedness, since `k1 < old_source1_num_rows',
       // we can increment index `k1' too.
       ++k1;
     }
     else if (cmp < 0) {
       // By sortedness, we can increment `k1'.
       ++k1;
     }
     else {
       // Here `cmp > 0'.
       // By sortedness, `source2[k2]' cannot be in `source1'.
       // We add it as a pending row of `source1' (sortedness unaffected).
       source1.add_pending_row(source2[k2]);
       // We can increment `k2'.
       ++k2;
     }
   }
   // Have we scanned all the rows in `source2'?
   if (k2 < source2_num_rows) {
     // By sortedness, all the rows in `source2' having indexes
     // greater than or equal to `k2' were not in `source1'.
     // We add them as pending rows of 'source1' (sortedness not affected).
     for ( ; k2 < source2_num_rows; ++k2) {
       source1.add_pending_row(source2[k2]);
     }
   }
 
   if (source1.num_pending_rows() == 0) {
     // No row was appended to `source1', because all the constraints
     // in `source2' were already in `source1'.
     // There is nothing left to do ...
     return false;
   }
   return add_and_minimize(con_to_gen, source1, dest, sat);
 }

template<typename Source_Linear_System , typename Dest_Linear_System >

bool Parma_Polyhedra_Library::Polyhedron::add_and_minimize	(	bool	con_to_gen,
		Source_Linear_System &	source,
		Dest_Linear_System &	dest,
		Bit_Matrix &	sat
	)

staticprivate

Adds given constraints and builds minimized corresponding generators or vice versa. The given constraints are in source.

Returns: true if the obtained polyhedron is empty, false otherwise.

Parameters

con_to_gen	`true` if `source` is a system of constraints, `false` otherwise;
source	The first element of the given DD pair. It also contains the pending rows to be processed;
dest	The second element of the given DD pair. It cannot have pending rows;
sat	The saturation matrix that bind the upper part of `source` to `dest`.

On entry, the rows of sat are indexed by the rows of dest and its columns are indexed by the non-pending rows of source. On exit, the rows of sat are indexed by the rows of dest and its columns are indexed by the rows of source.

Let us suppose that source is a system of constraints. This method assumes that the non-pending part of source and system dest form a double description pair in minimal form and will build a new DD pair in minimal form by processing the pending constraints in source. To this end, it will call conversion()) and simplify.

This method treats also the dual case, i.e., processing pending generators. In this case source contains generators and dest is the system of constraints corresponding to the non-pending part of source.

Definition at line 372 of file Polyhedron_minimize_templates.hh.

References conversion(), Parma_Polyhedra_Library::Bit_Matrix::resize(), and simplify().

                                               {
   PPL_ASSERT(source.num_pending_rows() > 0);
   PPL_ASSERT(source.space_dimension() == dest.space_dimension());
   PPL_ASSERT(source.is_sorted());
 
   // First, pad the saturation matrix with new columns (of zeroes)
   // to accommodate for the pending rows of `source'.
   sat.resize(dest.num_rows(), source.num_rows());
 
   // Incrementally compute the new system of generators.
   // Parameter `start' is set to the index of the first pending constraint.
   const dimension_type num_lines_or_equalities
     = conversion(source, source.first_pending_row(),
                  dest, sat,
                  dest.num_lines_or_equalities());
 
   // conversion() may have modified the number of rows in `dest'.
   const dimension_type dest_num_rows = dest.num_rows();
 
   // Checking if the generators in `dest' represent an empty polyhedron:
   // the polyhedron is empty if there are no points
   // (because rays, lines and closure points need a supporting point).
   // Points can be detected by looking at:
   // - the divisor, for necessarily closed polyhedra;
   // - the epsilon coordinate, for NNC polyhedra.
   dimension_type first_point;
   if (dest.is_necessarily_closed()) {
     for (first_point = num_lines_or_equalities;
         first_point < dest_num_rows;
         ++first_point) {
       if (dest[first_point].expr.inhomogeneous_term() > 0) {
         break;
       }
     }
   }
   else {
     for (first_point = num_lines_or_equalities;
         first_point < dest_num_rows;
         ++first_point) {
       if (dest[first_point].expr.get(Variable(dest.space_dimension())) > 0) {
         break;
       }
     }
   }
 
   if (first_point == dest_num_rows) {
     if (con_to_gen) {
       // No point has been found: the polyhedron is empty.
       return true;
     }
     else {
       // Here `con_to_gen' is false: `dest' is a system of constraints.
       // In this case the condition `first_point == dest_num_rows'
       // actually means that all the constraints in `dest' have their
       // inhomogeneous term equal to 0.
       // This is an ILLEGAL situation, because it implies that
       // the constraint system `dest' lacks the positivity constraint
       // and no linear combination of the constraints in `dest'
       // can reintroduce the positivity constraint.
       PPL_UNREACHABLE;
       return false;
     }
   }
   else {
     // A point has been found: the polyhedron is not empty.
     // Now invoking `simplify()' to remove all the redundant constraints
     // from the system `source'.
     // Since the saturation matrix `sat' returned by `conversion()'
     // has rows indexed by generators (the rows of `dest') and columns
     // indexed by constraints (the rows of `source'), we have to
     // transpose it to obtain the saturation matrix needed by `simplify()'.
     sat.transpose();
     simplify(source, sat);
     // Transposing back.
     sat.transpose();
     return false;
   }
 }

void Parma_Polyhedra_Library::Polyhedron::add_congruence ( const Congruence & cg )

Adds a copy of congruence cg to *this, if cg can be exactly represented by a polyhedron.

Exceptions

std::invalid_argument Thrown if *this and congruence cg are dimension-incompatible, of if cg is a proper congruence which is neither a tautology, nor a contradiction.

Definition at line 1329 of file Polyhedron_public.cc.

References c, Parma_Polyhedra_Library::Constraint::EQUALITY, Parma_Polyhedra_Library::Congruence::expression(), Parma_Polyhedra_Library::Congruence::is_equality(), Parma_Polyhedra_Library::Congruence::is_inconsistent(), Parma_Polyhedra_Library::Congruence::is_proper_congruence(), Parma_Polyhedra_Library::Congruence::is_tautological(), Parma_Polyhedra_Library::Boundary_NS::le(), Parma_Polyhedra_Library::NECESSARILY_CLOSED, and Parma_Polyhedra_Library::Congruence::space_dimension().

                                                   {
   // Dimension-compatibility check:
   // the dimension of `cg' can not be greater than space_dim.
   if (space_dim < cg.space_dimension()) {
     throw_dimension_incompatible("add_congruence(cg)", "cg", cg);
   }
 
   // Handle the case of proper congruences first.
   if (cg.is_proper_congruence()) {
     if (cg.is_tautological()) {
       return;
     }
     if (cg.is_inconsistent()) {
       set_empty();
       return;
     }
     // Non-trivial and proper congruences are not allowed.
     throw_invalid_argument("add_congruence(cg)",
                            "cg is a non-trivial, proper congruence");
   }
 
   PPL_ASSERT(cg.is_equality());
   // Handle empty and 0-dim cases first.
   if (marked_empty()) {
     return;
   }
   if (space_dim == 0) {
     if (cg.is_inconsistent()) {
       set_empty();
     }
     return;
   }
 
   // Add the equality.
   Linear_Expression le(cg.expression());
   const Constraint c(le, Constraint::EQUALITY, NECESSARILY_CLOSED);
   refine_no_check(c);
 }

void Parma_Polyhedra_Library::Polyhedron::add_congruences ( const Congruence_System & cgs )

Adds a copy of the congruences in cgs to *this, if all the congruences can be exactly represented by a polyhedron.

Parameters

cgs	The congruences to be added.

Exceptions

std::invalid_argument Thrown if *this and cgs are dimension-incompatible, of if there exists in cgs a proper congruence which is neither a tautology, nor a contradiction.

Definition at line 1707 of file Polyhedron_public.cc.

Referenced by add_recycled_congruences(), Parma_Polyhedra_Library::C_Polyhedron::C_Polyhedron(), and Parma_Polyhedra_Library::NNC_Polyhedron::NNC_Polyhedron().

                                                            {
   // Dimension-compatibility check.
   if (space_dim < cgs.space_dimension()) {
     throw_dimension_incompatible("add_congruences(cgs)", "cgs", cgs);
   }
 
   Constraint_System cs;
   bool inserted = false;
   for (Congruence_System::const_iterator i = cgs.begin(),
          cgs_end = cgs.end(); i != cgs_end; ++i) {
     const Congruence& cg = *i;
     if (cg.is_equality()) {
       Linear_Expression le(cg.expression());
       const Constraint c(le, Constraint::EQUALITY, NECESSARILY_CLOSED);
 
       // TODO: Consider stealing the row in c when adding it to cs.
       cs.insert(c);
       inserted = true;
     }
     else {
       PPL_ASSERT(cg.is_proper_congruence());
       if (cg.is_inconsistent()) {
         set_empty();
         return;
       }
       if (!cg.is_tautological()) {
         throw_invalid_argument("add_congruences(cgs)",
                                "cgs has a non-trivial, proper congruence");
       }
     }
   }
   // Only add cs if it contains something.
   if (inserted) {
     add_recycled_constraints(cs);
   }
 }

void Parma_Polyhedra_Library::Polyhedron::add_constraint ( const Constraint & c )

Adds a copy of constraint c to the system of constraints of *this (without minimizing the result).

Parameters

c	The constraint that will be added to the system of constraints of `*this`.

Exceptions

std::invalid_argument Thrown if *this and constraint c are topology-incompatible or dimension-incompatible.

Definition at line 1301 of file Polyhedron_public.cc.

References Parma_Polyhedra_Library::Constraint::is_inconsistent(), Parma_Polyhedra_Library::Constraint::is_strict_inequality(), Parma_Polyhedra_Library::Constraint::is_tautological(), and Parma_Polyhedra_Library::Constraint::space_dimension().

Referenced by Parma_Polyhedra_Library::Pointset_Powerset< PSET >::affine_dimension(), Parma_Polyhedra_Library::Termination_Helpers::all_affine_ranking_functions_PR(), Parma_Polyhedra_Library::Termination_Helpers::all_affine_ranking_functions_PR_original(), BHZ09_NNC_poly_hull_assign_if_exact(), Parma_Polyhedra_Library::C_Polyhedron::C_Polyhedron(), and Parma_Polyhedra_Library::Pointset_Powerset< PSET >::linear_partition_aux().

                                                  {
   // Topology-compatibility check.
   if (c.is_strict_inequality() && is_necessarily_closed()) {
     // Trivially true/false strict inequalities are legal.
     if (c.is_tautological()) {
       return;
     }
     if (c.is_inconsistent()) {
       set_empty();
       return;
     }
     // Here c is a non-trivial strict inequality.
     throw_topology_incompatible("add_constraint(c)", "c", c);
   }
 
   // Dimension-compatibility check:
   // the dimension of `c' can not be greater than space_dim.
   if (space_dim < c.space_dimension()) {
     throw_dimension_incompatible("add_constraint(c)", "c", c);
   }
 
   if (!marked_empty()) {
     refine_no_check(c);
   }
 
 }

void Parma_Polyhedra_Library::Polyhedron::add_constraints ( const Constraint_System & cs )

Adds a copy of the constraints in cs to the system of constraints of *this (without minimizing the result).

Parameters

cs	Contains the constraints that will be added to the system of constraints of `*this`.

Exceptions

std::invalid_argument Thrown if *this and cs are topology-incompatible or dimension-incompatible.

Definition at line 1602 of file Polyhedron_public.cc.

Referenced by Parma_Polyhedra_Library::C_Polyhedron::C_Polyhedron(), Parma_Polyhedra_Library::NNC_Polyhedron::NNC_Polyhedron(), and simplify_using_context_assign().

                                                           {
   // TODO: this is just an executable specification.
   Constraint_System cs_copy = cs;
   add_recycled_constraints(cs_copy);
 }

void Parma_Polyhedra_Library::Polyhedron::add_generator ( const Generator & g )

Adds a copy of generator g to the system of generators of *this (without minimizing the result).

Exceptions

std::invalid_argument Thrown if *this and generator g are topology-incompatible or dimension-incompatible, or if *this is an empty polyhedron and g is not a point.

Definition at line 1369 of file Polyhedron_public.cc.

Referenced by BHZ09_NNC_poly_hull_assign_if_exact().

                                                {
   // Topology-compatibility check.
   if (g.is_closure_point() && is_necessarily_closed()) {
     throw_topology_incompatible("add_generator(g)", "g", g);
   }
   // Dimension-compatibility check:
   // the dimension of `g' can not be greater than space_dim.
   const dimension_type g_space_dim = g.space_dimension();
   if (space_dim < g_space_dim) {
     throw_dimension_incompatible("add_generator(g)", "g", g);
   }
   // Dealing with a zero-dimensional space polyhedron first.
   if (space_dim == 0) {
     // It is not possible to create 0-dim rays or lines.
     PPL_ASSERT(g.is_point() || g.is_closure_point());
     // Closure points can only be inserted in non-empty polyhedra.
     if (marked_empty()) {
       if (g.type() != Generator::POINT) {
         throw_invalid_generator("add_generator(g)", "g");
       }
       else {
         set_zero_dim_univ();
       }
     }
     PPL_ASSERT_HEAVY(OK());
     return;
   }
 
   if (marked_empty()
       || (has_pending_constraints() && !process_pending_constraints())
       || (!generators_are_up_to_date() && !update_generators())) {
     // Here the polyhedron is empty:
     // the specification says we can only insert a point.
     if (!g.is_point()) {
       throw_invalid_generator("add_generator(g)", "g");
     }
     if (g.is_necessarily_closed() || !is_necessarily_closed()) {
       gen_sys.insert(g);
       // Since `gen_sys' was empty, after inserting `g' we have to resize
       // the system of generators to have the right dimension.
       gen_sys.adjust_topology_and_space_dimension(topology(), space_dim);
       if (!is_necessarily_closed()) {
         // In the NNC topology, each point has to be matched by
         // a corresponding closure point:
         // turn the just inserted point into the corresponding
         // (normalized) closure point.
         gen_sys.sys.rows.back().set_epsilon_coefficient(0);
         gen_sys.sys.rows.back().expr.normalize();
         PPL_ASSERT(gen_sys.sys.rows.back().OK());
         PPL_ASSERT(gen_sys.sys.OK());
         // Re-insert the point (which is already normalized).
         gen_sys.insert(g);
       }
     }
     else {
       // Note: here we have a _legal_ topology mismatch,
       // because `g' is NOT a closure point (it is a point!)
       // However, by barely invoking `gen_sys.insert(g)' we would
       // cause a change in the topology of `gen_sys', which is wrong.
       // Thus, we insert a "topology corrected" copy of `g'.
       const Linear_Expression nc_expr(g.expression());
       gen_sys.insert(Generator::point(nc_expr, g.divisor()));
       // Since `gen_sys' was empty, after inserting `g' we have to resize
       // the system of generators to have the right dimension.
       gen_sys.adjust_topology_and_space_dimension(topology(), space_dim);
     }
     // No longer empty, generators up-to-date and minimized.
     clear_empty();
     set_generators_minimized();
   }
   else {
     PPL_ASSERT(generators_are_up_to_date());
     const bool has_pending = can_have_something_pending();
     if (g.is_necessarily_closed() || !is_necessarily_closed()) {
       // Since `gen_sys' is not empty, the topology and space dimension
       // of the inserted generator are automatically adjusted.
       if (has_pending) {
         gen_sys.insert_pending(g);
       }
       else {
         gen_sys.insert(g);
       }
       if (!is_necessarily_closed() && g.is_point()) {
         // In the NNC topology, each point has to be matched by
         // a corresponding closure point:
         // turn the just inserted point into the corresponding
         // (normalized) closure point.
         gen_sys.sys.rows.back().set_epsilon_coefficient(0);
         gen_sys.sys.rows.back().expr.normalize();
         PPL_ASSERT(gen_sys.sys.rows.back().OK());
         PPL_ASSERT(gen_sys.sys.OK());
         // Re-insert the point (which is already normalized).
         if (has_pending) {
           gen_sys.insert_pending(g);
         }
         else {
           gen_sys.insert(g);
         }
       }
     }
     else {
       PPL_ASSERT(!g.is_closure_point());
       // Note: here we have a _legal_ topology mismatch, because
       // `g' is NOT a closure point.
       // However, by barely invoking `gen_sys.insert(g)' we would
       // cause a change in the topology of `gen_sys', which is wrong.
       // Thus, we insert a "topology corrected" copy of `g'.
       const Linear_Expression nc_expr(g.expression());
       switch (g.type()) {
       case Generator::LINE:
         if (has_pending) {
           gen_sys.insert_pending(Generator::line(nc_expr));
         }
         else {
           gen_sys.insert(Generator::line(nc_expr));
         }
         break;
       case Generator::RAY:
         if (has_pending) {
           gen_sys.insert_pending(Generator::ray(nc_expr));
         }
         else {
           gen_sys.insert(Generator::ray(nc_expr));
         }
         break;
       case Generator::POINT:
         if (has_pending) {
           gen_sys.insert_pending(Generator::point(nc_expr, g.divisor()));
         }
         else {
           gen_sys.insert(Generator::point(nc_expr, g.divisor()));
         }
         break;
       case Generator::CLOSURE_POINT:
         PPL_UNREACHABLE;
         break;
       }
     }
 
     if (has_pending) {
       set_generators_pending();
     }
     else {
       // After adding the new generator,
       // constraints are no longer up-to-date.
       clear_generators_minimized();
       clear_constraints_up_to_date();
     }
   }
   PPL_ASSERT_HEAVY(OK());
 }

void Parma_Polyhedra_Library::Polyhedron::add_generators ( const Generator_System & gs )

Adds a copy of the generators in gs to the system of generators of *this (without minimizing the result).

Parameters

gs	Contains the generators that will be added to the system of generators of `*this`.

Exceptions

std::invalid_argument Thrown if *this and gs are topology-incompatible or dimension-incompatible, or if *this is empty and the system of generators gs is not empty, but has no points.

Definition at line 1700 of file Polyhedron_public.cc.

                                                         {
   // TODO: this is just an executable specification.
   Generator_System gs_copy = gs;
   add_recycled_generators(gs_copy);
 }

void Parma_Polyhedra_Library::Polyhedron::add_recycled_congruences ( Congruence_System & cgs )

inline

Adds the congruences in cgs to *this, if all the congruences can be exactly represented by a polyhedron.

Parameters

cgs	The congruences to be added. Its elements may be recycled.

Exceptions

std::invalid_argument Thrown if *this and cgs are dimension-incompatible, of if there exists in cgs a proper congruence which is neither a tautology, nor a contradiction

Warning: The only assumption that can be made on cgs upon successful or exceptional return is that it can be safely destroyed.

Definition at line 377 of file Polyhedron_inlines.hh.

References add_congruences().

                                                            {
   add_congruences(cgs);
 }

void Parma_Polyhedra_Library::Polyhedron::add_recycled_constraints ( Constraint_System & cs )

Adds the constraints in cs to the system of constraints of *this (without minimizing the result).

Parameters

cs	The constraint system to be added to `*this`. The constraints in `cs` may be recycled.

Exceptions

std::invalid_argument Thrown if *this and cs are topology-incompatible or dimension-incompatible.

Warning: The only assumption that can be made on cs upon successful or exceptional return is that it can be safely destroyed.

Definition at line 1522 of file Polyhedron_public.cc.

References Parma_Polyhedra_Library::Constraint_System::adjust_topology_and_space_dimension(), Parma_Polyhedra_Library::Constraint_System::begin(), Parma_Polyhedra_Library::Constraint_System::end(), Parma_Polyhedra_Library::Constraint_System::has_no_rows(), Parma_Polyhedra_Library::Constraint_System::has_strict_inequalities(), and Parma_Polyhedra_Library::Constraint_System::space_dimension().

Referenced by BHRZ03_combining_constraints(), H79_widening_assign(), limited_BHRZ03_extrapolation_assign(), limited_H79_extrapolation_assign(), and simplify_using_context_assign().

                                                              {
   // Topology compatibility check.
   if (is_necessarily_closed() && cs.has_strict_inequalities()) {
     // We check if _all_ strict inequalities in cs are trivially false.
     // (The iterators already filter away trivially true constraints.)
     for (Constraint_System::const_iterator i = cs.begin(),
            i_end = cs.end(); i != i_end; ++i) {
       if (i->is_strict_inequality()
           && !i->is_inconsistent()) {
         throw_topology_incompatible("add_recycled_constraints(cs)",
                                     "cs", cs);
       }
     }
     // If we reach this point, all strict inequalities were inconsistent.
     set_empty();
     return;
   }
 
   // Dimension-compatibility check:
   // the dimension of `cs' can not be greater than space_dim.
   const dimension_type cs_space_dim = cs.space_dimension();
   if (space_dim < cs_space_dim) {
     throw_dimension_incompatible("add_recycled_constraints(cs)", "cs", cs);
   }
   // Adding no constraints is a no-op.
   if (cs.has_no_rows()) {
     return;
   }
 
   if (space_dim == 0) {
     // In a 0-dimensional space the constraints are
     // tautologies (e.g., 0 == 0 or 1 >= 0 or 1 > 0) or
     // inconsistent (e.g., 1 == 0 or -1 >= 0 or 0 > 0).
     // In a system of constraints `begin()' and `end()' are equal
     // if and only if the system only contains tautologies.
     if (cs.begin() != cs.end()) {
       // There is a constraint, it must be inconsistent,
       // the polyhedron is empty.
       status.set_empty();
     }
     return;
   }
 
   if (marked_empty()) {
     return;
   }
 
   // The constraints (possibly with pending rows) are required.
   if (has_pending_generators()) {
     process_pending_generators();
   }
   else if (!constraints_are_up_to_date()) {
     update_constraints();
   }
 
   // Adjust `cs' to the right topology and space dimension.
   // NOTE: we already checked for topology compatibility.
   cs.adjust_topology_and_space_dimension(topology(), space_dim);
 
   const bool adding_pending = can_have_something_pending();
 
   // Here we do not require `con_sys' to be sorted.
   // also, we _recycle_ (instead of copying) the coefficients of `cs'.
   if (adding_pending) {
     con_sys.insert_pending(cs, Recycle_Input());
     set_constraints_pending();
   }
   else {
     con_sys.insert(cs, Recycle_Input());
     // Constraints are not minimized and generators are not up-to-date.
     clear_constraints_minimized();
     clear_generators_up_to_date();
   }
 
   // Note: the constraint system may have become unsatisfiable, thus
   // we do not check for satisfiability.
   PPL_ASSERT_HEAVY(OK());
 }

void Parma_Polyhedra_Library::Polyhedron::add_recycled_generators ( Generator_System & gs )

Adds the generators in gs to the system of generators of *this (without minimizing the result).

Parameters

gs	The generator system to be added to `*this`. The generators in `gs` may be recycled.

Exceptions

std::invalid_argument Thrown if *this and gs are topology-incompatible or dimension-incompatible, or if *this is empty and the system of generators gs is not empty, but has no points.

Warning: The only assumption that can be made on gs upon successful or exceptional return is that it can be safely destroyed.

Definition at line 1609 of file Polyhedron_public.cc.

Referenced by BHRZ03_evolving_points(), and BHRZ03_evolving_rays().

                                                            {
   // Topology compatibility check.
   if (is_necessarily_closed() && gs.has_closure_points()) {
     throw_topology_incompatible("add_recycled_generators(gs)", "gs", gs);
   }
   // Dimension-compatibility check:
   // the dimension of `gs' can not be greater than space_dim.
   const dimension_type gs_space_dim = gs.space_dimension();
   if (space_dim < gs_space_dim) {
     throw_dimension_incompatible("add_recycled_generators(gs)", "gs", gs);
   }
 
   // Adding no generators is a no-op.
   if (gs.has_no_rows()) {
     return;
   }
 
   // Adding valid generators to a zero-dimensional polyhedron
   // transform it in the zero-dimensional universe polyhedron.
   if (space_dim == 0) {
     if (marked_empty() && !gs.has_points()) {
       throw_invalid_generators("add_recycled_generators(gs)", "gs");
     }
     set_zero_dim_univ();
     PPL_ASSERT_HEAVY(OK(true));
     return;
   }
 
   // Adjust `gs' to the right topology and dimensions.
   // NOTE: we already checked for topology compatibility.
   gs.adjust_topology_and_space_dimension(topology(), space_dim);
   // For NNC polyhedra, each point must be matched by
   // the corresponding closure point.
   if (!is_necessarily_closed()) {
     gs.add_corresponding_closure_points();
   }
 
   // The generators (possibly with pending rows) are required.
   if ((has_pending_constraints() && !process_pending_constraints())
       || (!generators_are_up_to_date() && !minimize())) {
     // We have just discovered that `*this' is empty.
     // So `gs' must contain at least one point.
     if (!gs.has_points()) {
       throw_invalid_generators("add_recycled_generators(gs)", "gs");
     }
     // The polyhedron is no longer empty and generators are up-to-date.
     swap(gen_sys, gs);
     if (gen_sys.num_pending_rows() > 0) {
       // Even though `gs' has pending generators, since the constraints
       // of the polyhedron are not up-to-date, the polyhedron cannot
       // have pending generators. By integrating the pending part
       // of `gen_sys' we may loose sortedness.
       gen_sys.sys.index_first_pending = gen_sys.num_rows();
       gen_sys.set_sorted(false);
     }
     set_generators_up_to_date();
     clear_empty();
     PPL_ASSERT_HEAVY(OK());
     return;
   }
 
   if (can_have_something_pending()) {
     // Here we do not require `gen_sys' to be sorted.
     // also, we _remove_ (instead of copying) the rows of `gs'
     // (which is not a const).
     for (dimension_type i = 0; i < gs.num_rows(); ++i) {
       gs.sys.rows[i].set_topology(topology());
       gen_sys.insert_pending(gs.sys.rows[i], Recycle_Input());
     }
     gs.clear();
 
     set_generators_pending();
   }
   else {
     // Here we do not require `gen_sys' to be sorted.
     // also, we _remove_ (instead of copying) the coefficients of `gs'
     // (which is not a const).
     for (dimension_type i = 0; i < gs.num_rows(); ++i) {
       gs.sys.rows[i].set_topology(topology());
       gen_sys.insert(gs.sys.rows[i], Recycle_Input());
     }
     gs.clear();
 
     // Constraints are not up-to-date and generators are not minimized.
     clear_constraints_up_to_date();
     clear_generators_minimized();
   }
   PPL_ASSERT_HEAVY(OK(true));
 }

template<typename Linear_System1 , typename Linear_System2 >

void Parma_Polyhedra_Library::Polyhedron::add_space_dimensions	(	Linear_System1 &	sys1,
		Linear_System2 &	sys2,
		Bit_Matrix &	sat1,
		Bit_Matrix &	sat2,
		dimension_type	add_dim
	)

staticprivate

Adds new space dimensions to the given linear systems.

Parameters

sys1	The linear system to which columns are added;
sys2	The linear system to which rows and columns are added;
sat1	The saturation matrix whose columns are indexed by the rows of `sys1`. On entry it is up-to-date;
sat2	The saturation matrix whose columns are indexed by the rows of `sys2`;
add_dim	The number of space dimensions to add.

Adds new space dimensions to the vector space modifying the linear systems and saturation matrices. This function is invoked only by add_space_dimensions_and_embed() and add_space_dimensions_and_project(), passing the linear system of constraints and that of generators (and the corresponding saturation matrices) in different order (see those methods for details).

Definition at line 32 of file Polyhedron_chdims_templates.hh.

References Parma_Polyhedra_Library::Bit_Matrix::num_columns(), Parma_Polyhedra_Library::Bit_Matrix::num_rows(), Parma_Polyhedra_Library::Bit_Matrix::resize(), swap(), and Parma_Polyhedra_Library::Bit_Matrix::transpose_assign().

Referenced by add_space_dimensions_and_embed().

                                                          {
   PPL_ASSERT(sys1.topology() == sys2.topology());
   PPL_ASSERT(sys1.space_dimension() == sys2.space_dimension());
   PPL_ASSERT(add_dim != 0);
 
   sys1.set_space_dimension(sys1.space_dimension() + add_dim);
   sys2.add_universe_rows_and_space_dimensions(add_dim);
 
   // The resulting saturation matrix will be as follows:
   // from row    0    to      add_dim-1       : only zeroes
   //          add_dim     add_dim+num_rows-1  : old saturation matrix
 
   // In fact all the old generators saturate all the new constraints
   // because the polyhedron has not been embedded in the new space.
   sat1.resize(sat1.num_rows() + add_dim, sat1.num_columns());
   // The old matrix is moved to the end of the new matrix.
   for (dimension_type i = sat1.num_rows() - add_dim; i-- > 0; ) {
     swap(sat1[i], sat1[i+add_dim]);
   }
   // Computes the "sat_c", too.
   sat2.transpose_assign(sat1);
 }

void Parma_Polyhedra_Library::Polyhedron::add_space_dimensions_and_embed ( dimension_type m )

Adds m new space dimensions and embeds the old polyhedron in the new vector space.

Parameters

m	The number of dimensions to add.

Exceptions

std::length_error Thrown if adding m new space dimensions would cause the vector space to exceed dimension max_space_dimension().

The new space dimensions will be those having the highest indexes in the new polyhedron, which is characterized by a system of constraints in which the variables running through the new dimensions are not constrained. For instance, when starting from the polyhedron $\cP \sseq \Rset^2$ and adding a third space dimension, the result will be the polyhedron

$\bigl\{\, (x, y, z)^\transpose \in \Rset^3 \bigm| (x, y)^\transpose \in \cP \,\bigr\}.$

Definition at line 35 of file Polyhedron_chdims.cc.

References add_space_dimensions(), Parma_Polyhedra_Library::Generator_System::add_universe_rows_and_space_dimensions(), check_space_dimension_overflow(), Parma_Polyhedra_Library::Constraint_System::clear(), con_sys, constraints_are_up_to_date(), gen_sys, generators_are_up_to_date(), m_swap(), marked_empty(), max_space_dimension(), OK(), sat_c, sat_c_is_up_to_date(), sat_g, Parma_Polyhedra_Library::Constraint_System::set_space_dimension(), space_dim, Parma_Polyhedra_Library::Constraint_System::space_dimension(), space_dimension(), status, Parma_Polyhedra_Library::Polyhedron::Status::test_zero_dim_univ(), topology(), Parma_Polyhedra_Library::UNIVERSE, and update_sat_c().

Referenced by Parma_Polyhedra_Library::Implementation::Termination::all_affine_quasi_ranking_functions_MS(), Parma_Polyhedra_Library::Implementation::Termination::all_affine_ranking_functions_MS(), Parma_Polyhedra_Library::Termination_Helpers::all_affine_ranking_functions_PR(), and Parma_Polyhedra_Library::Termination_Helpers::all_affine_ranking_functions_PR_original().

                                                               {
   // The space dimension of the resulting polyhedron should not
   // overflow the maximum allowed space dimension.
   check_space_dimension_overflow(m, max_space_dimension() - space_dimension(),
                                  topology(),
                                  "add_space_dimensions_and_embed(m)",
                                  "adding m new space dimensions exceeds "
                                  "the maximum allowed space dimension");
 
   // Adding no dimensions to any polyhedron is a no-op.
   if (m == 0) {
     return;
   }
 
   // Adding dimensions to an empty polyhedron is obtained by adjusting
   // `space_dim' and clearing `con_sys' (since it can contain the
   // unsatisfiable constraint system of the wrong dimension).
   if (marked_empty()) {
     space_dim += m;
     con_sys.clear();
     return;
   }
 
   // The case of a zero-dimensional space polyhedron.
   if (space_dim == 0) {
     // Since it is not empty, it has to be the universe polyhedron.
     PPL_ASSERT(status.test_zero_dim_univ());
     // We swap `*this' with a newly created
     // universe polyhedron of dimension `m'.
     Polyhedron ph(topology(), m, UNIVERSE);
     m_swap(ph);
     return;
   }
 
   // To embed an n-dimension space polyhedron in a (n+m)-dimension space,
   // we just add `m' zero-columns to the rows in the system of constraints;
   // in contrast, the system of generators needs additional rows,
   // corresponding to the vectors of the canonical basis
   // for the added dimensions. That is, for each new dimension `x[k]'
   // we add the line having that direction. This is done by invoking
   // the function add_space_dimensions() giving the system of generators
   // as the second argument.
   if (constraints_are_up_to_date()) {
     if (generators_are_up_to_date()) {
       // `sat_c' must be up to date for add_space_dimensions().
       if (!sat_c_is_up_to_date()) {
         update_sat_c();
       }
       // Adds rows and/or columns to both matrices.
       // `add_space_dimensions' correctly handles pending constraints
       // or generators.
       add_space_dimensions(con_sys, gen_sys, sat_c, sat_g, m);
     }
     else {
       // Only constraints are up-to-date: no need to modify the generators.
       con_sys.set_space_dimension(con_sys.space_dimension() + m);
     }
   }
   else {
     // Only generators are up-to-date: no need to modify the constraints.
     PPL_ASSERT(generators_are_up_to_date());
     gen_sys.add_universe_rows_and_space_dimensions(m);
   }
   // Update the space dimension.
   space_dim += m;
 
   // Note: we do not check for satisfiability, because the system of
   // constraints may be unsatisfiable.
   PPL_ASSERT_HEAVY(OK());
 }

void Parma_Polyhedra_Library::Polyhedron::add_space_dimensions_and_project ( dimension_type m )

Adds m new space dimensions to the polyhedron and does not embed it in the new vector space.

Parameters

m	The number of space dimensions to add.

Exceptions

std::length_error Thrown if adding m new space dimensions would cause the vector space to exceed dimension max_space_dimension().

The new space dimensions will be those having the highest indexes in the new polyhedron, which is characterized by a system of constraints in which the variables running through the new dimensions are all constrained to be equal to 0. For instance, when starting from the polyhedron $\cP \sseq \Rset^2$ and adding a third space dimension, the result will be the polyhedron

$\bigl\{\, (x, y, 0)^\transpose \in \Rset^3 \bigm| (x, y)^\transpose \in \cP \,\bigr\}.$

Definition at line 107 of file Polyhedron_chdims.cc.

References Parma_Polyhedra_Library::check_space_dimension_overflow(), Parma_Polyhedra_Library::max_space_dimension(), Parma_Polyhedra_Library::Generator::zero_dim_closure_point(), and Parma_Polyhedra_Library::Generator::zero_dim_point().

                                                                 {
   // The space dimension of the resulting polyhedron should not
   // overflow the maximum allowed space dimension.
   check_space_dimension_overflow(m, max_space_dimension() - space_dimension(),
                                  topology(),
                                  "add_space_dimensions_and_project(m)",
                                  "adding m new space dimensions exceeds "
                                  "the maximum allowed space dimension");
 
   // Adding no dimensions to any polyhedron is a no-op.
   if (m == 0) {
     return;
   }
 
   // Adding dimensions to an empty polyhedron is obtained
   // by merely adjusting `space_dim'.
   if (marked_empty()) {
     space_dim += m;
     con_sys.clear();
     return;
   }
 
   if (space_dim == 0) {
     PPL_ASSERT(status.test_zero_dim_univ() && gen_sys.has_no_rows());
     // The system of generators for this polyhedron has only
     // the origin as a point.
     // In an NNC polyhedron, all points have to be accompanied
     // by the corresponding closure points
     // (this time, dimensions are automatically adjusted).
     if (!is_necessarily_closed()) {
       gen_sys.insert(Generator::zero_dim_closure_point());
     }
     gen_sys.insert(Generator::zero_dim_point());
     gen_sys.adjust_topology_and_space_dimension(topology(), m);
     set_generators_minimized();
     space_dim = m;
     PPL_ASSERT_HEAVY(OK());
     return;
   }
 
   // To project an n-dimension space polyhedron in a (n+m)-dimension space,
   // we just add to the system of generators `m' zero-columns;
   // In contrast, in the system of constraints, new rows are needed
   // in order to avoid embedding the old polyhedron in the new space.
   // Thus, for each new dimensions `x[k]', we add the constraint
   // x[k] = 0: this is done by invoking the function add_space_dimensions()
   // giving the system of constraints as the second argument.
   if (constraints_are_up_to_date()) {
     if (generators_are_up_to_date()) {
       // `sat_g' must be up to date for add_space_dimensions().
       if (!sat_g_is_up_to_date()) {
         update_sat_g();
       }
       // Adds rows and/or columns to both matrices.
       // `add_space_dimensions()' correctly handles pending constraints
       // or generators.
       add_space_dimensions(gen_sys, con_sys, sat_g, sat_c, m);
     }
     else {
       // Only constraints are up-to-date: no need to modify the generators.
       con_sys.add_universe_rows_and_space_dimensions(m);
     }
   }
   else {
     // Only generators are up-to-date: no need to modify the constraints.
     PPL_ASSERT(generators_are_up_to_date());
     gen_sys.set_space_dimension(gen_sys.space_dimension() + m);
   }
   // Now we update the space dimension.
   space_dim += m;
 
   // Note: we do not check for satisfiability, because the system of
   // constraints may be unsatisfiable.
   PPL_ASSERT_HEAVY(OK());
 }

template<typename Linear_System1 , typename Row2 >

bool Parma_Polyhedra_Library::Polyhedron::add_to_system_and_check_independence	(	Linear_System1 &	eq_sys,
		const Row2 &	eq
	)

staticprotected

Definition at line 2135 of file Polyhedron_public.cc.

                                                                       {
   // Check if eq is linearly independent from eq_sys.
   PPL_ASSERT(eq.is_line_or_equality());
   eq_sys.insert(eq);
   const PPL::dimension_type eq_sys_num_rows = eq_sys.num_rows();
   const PPL::dimension_type rank = eq_sys.gauss(eq_sys_num_rows);
   if (rank == eq_sys_num_rows) {
     // eq is linearly independent from eq_sys.
     return true;
   }
   else {
     // eq is not linearly independent from eq_sys.
     PPL_ASSERT(rank == eq_sys_num_rows - 1);
     eq_sys.remove_trailing_rows(1);
     return false;
   }
 }

PPL::dimension_type Parma_Polyhedra_Library::Polyhedron::affine_dimension ( ) const

Returns $0$ , if *this is empty; otherwise, returns the affine dimension of *this.

Definition at line 61 of file Polyhedron_public.cc.

References Parma_Polyhedra_Library::Constraint_System::begin(), and Parma_Polyhedra_Library::Constraint_System::end().

Referenced by Parma_Polyhedra_Library::Pointset_Powerset< PSET >::affine_dimension(), BHZ09_C_poly_hull_assign_if_exact(), and is_discrete().

                                       {
   if (is_empty()) {
     return 0;
   }
 
   const Constraint_System& cs = minimized_constraints();
   dimension_type d = space_dim;
   for (Constraint_System::const_iterator i = cs.begin(),
          cs_end = cs.end(); i != cs_end; ++i) {
     if (i->is_equality()) {
       --d;
     }
   }
   return d;
 }

template<typename FP_Format , typename Interval_Info >

void Parma_Polyhedra_Library::Polyhedron::affine_form_image	(	Variable	var,
		const Linear_Form< Interval< FP_Format, Interval_Info > > &	lf
	)

Assigns to *this the affine form image of *this under the function mapping variable var into the affine expression(s) specified by lf.

Parameters

var	The variable to which the affine expression is assigned.
lf	The linear form on intervals with floating point boundaries that defines the affine expression(s). ALL of its coefficients MUST be bounded.

Exceptions

std::invalid_argument Thrown if lf and *this are dimension-incompatible or if var is not a space dimension of *this.

This function is used in abstract interpretation to model an assignment of a value that is correctly overapproximated by lf to the floating point variable represented by var.

Definition at line 372 of file Polyhedron_templates.hh.

References bounded_affine_image(), convert_to_integer_expressions(), Parma_Polyhedra_Library::Variable::id(), marked_empty(), overapproximate_linear_form(), Polyhedron(), PPL_COMPILE_TIME_CHECK, PPL_DIRTY_TEMP_COEFFICIENT, space_dim, throw_dimension_incompatible(), topology(), and Parma_Polyhedra_Library::UNIVERSE.

                                                              {
 
   // Check that FP_Format is indeed a floating point type.
   PPL_COMPILE_TIME_CHECK(!std::numeric_limits<FP_Format>::is_exact,
                          "Polyhedron::affine_form_image:"
                          " FP_Format not a floating point type.");
 
   // Dimension compatibility checks.
   // The dimension of lf should not be greater than the dimension of *this.
   const dimension_type lf_space_dim = lf.space_dimension();
   if (space_dim < lf_space_dim) {
     throw_dimension_incompatible("affine_form_image(v, l, s)", "l", lf);
   }
 
   // `var' should be one of the dimensions of the polyhedron.
   const dimension_type var_id = var.id();
   if (space_dim < var_id + 1) {
     throw_dimension_incompatible("affine_form_image(v, l, s)", "v", var);
   }
 
   // We assume that the analyzer will not perform an unreachable assignment.
   PPL_ASSERT(!marked_empty());
 
   typedef Interval<FP_Format, Interval_Info> FP_Interval_Type;
   typedef Linear_Form<FP_Interval_Type> FP_Linear_Form;
 
   if (Floating_Point_Expression<FP_Interval_Type, float_ieee754_single>::
       overflows(lf)) {
     *this = Polyhedron(topology(), space_dim, UNIVERSE);
     return;
   }
 
   // Overapproximate lf.
   FP_Linear_Form lf_approx;
   overapproximate_linear_form(lf, lf_space_dim, lf_approx);
 
   if (Floating_Point_Expression<FP_Interval_Type, float_ieee754_single>::
       overflows(lf_approx)) {
     *this = Polyhedron(topology(), space_dim, UNIVERSE);
     return;
   }
 
   // Normalize lf.
   Linear_Expression lf_approx_le;
   PPL_DIRTY_TEMP_COEFFICIENT(lo_coeff);
   PPL_DIRTY_TEMP_COEFFICIENT(hi_coeff);
   PPL_DIRTY_TEMP_COEFFICIENT(denominator);
   convert_to_integer_expressions(lf_approx, lf_space_dim, lf_approx_le,
                                  lo_coeff, hi_coeff, denominator);
 
   // Finally, do the assignment.
   bounded_affine_image(var, lf_approx_le + lo_coeff, lf_approx_le + hi_coeff,
                        denominator);
 }

void Parma_Polyhedra_Library::Polyhedron::affine_image	(	Variable	var,
		const Linear_Expression &	expr,
		Coefficient_traits::const_reference	denominator = `Coefficient_one()`
	)

Assigns to *this the affine image of *this under the function mapping variable var to the affine expression specified by expr and denominator.

Parameters

var	The variable to which the affine expression is assigned;
expr	The numerator of the affine expression;
denominator	The denominator of the affine expression (optional argument with default value 1).

Exceptions

std::invalid_argument Thrown if denominator is zero or if expr and *this are dimension-incompatible or if var is not a space dimension of *this.

When considering the generators of a polyhedron, the affine transformation

$\frac{\sum_{i=0}^{n-1} a_i x_i + b}{\mathrm{denominator}}$

is assigned to var where expr is $\sum_{i=0}^{n-1} a_i x_i + b$ ( $b$ is the inhomogeneous term).

If constraints are up-to-date, it uses the specialized function affine_preimage() (for the system of constraints) and inverse transformation to reach the same result. To obtain the inverse transformation we use the following observation.

Observation:

The affine transformation is invertible if the coefficient of var in this transformation (i.e., $a_\mathrm{var}$ ) is different from zero.
If the transformation is invertible, then we can write
$\mathrm{denominator} * {x'}_\mathrm{var} = \sum_{i = 0}^{n - 1} a_i x_i + b = a_\mathrm{var} x_\mathrm{var} + \sum_{i \neq var} a_i x_i + b,$
so that the inverse transformation is
$a_\mathrm{var} x_\mathrm{var} = \mathrm{denominator} * {x'}_\mathrm{var} - \sum_{i \neq j} a_i x_i - b.$

Then, if the transformation is invertible, all the entities that were up-to-date remain up-to-date. Otherwise only generators remain up-to-date.

In other words, if $R$ is a $m_1 \times n$ matrix representing the rays of the polyhedron, $V$ is a $m_2 \times n$ matrix representing the points of the polyhedron and

$P = \bigl\{\, \vect{x} = (x_0, \ldots, x_{n-1})^\mathrm{T} \bigm| \vect{x} = \vect{\lambda} R + \vect{\mu} V, \vect{\lambda} \in \Rset^{m_1}_+, \vect{\mu} \in \Rset^{m_2}_+, \sum_{i = 0}^{m_2 - 1} \mu_i = 1 \,\bigr\}$

and $T$ is the affine transformation to apply to $P$ , then the resulting polyhedron is

$P' = \bigl\{\, (x_0, \ldots, T(x_0, \ldots, x_{n-1}), \ldots, x_{n-1})^\mathrm{T} \bigm| (x_0, \ldots, x_{n-1})^\mathrm{T} \in P \,\bigr\}.$

Affine transformations are, for example:

translations
rotations
symmetries.

Definition at line 2745 of file Polyhedron_public.cc.

References c, Parma_Polyhedra_Library::Linear_Expression::coefficient(), Parma_Polyhedra_Library::inverse(), Parma_Polyhedra_Library::Linear_Expression::set_coefficient(), Parma_Polyhedra_Library::Variable::space_dimension(), and Parma_Polyhedra_Library::Linear_Expression::space_dimension().

Referenced by fold_space_dimensions().

                                                             {
   // The denominator cannot be zero.
   if (denominator == 0) {
     throw_invalid_argument("affine_image(v, e, d)", "d == 0");
   }
   // Dimension-compatibility checks.
   // The dimension of `expr' should not be greater than the dimension
   // of `*this'.
   if (space_dim < expr.space_dimension()) {
     throw_dimension_incompatible("affine_image(v, e, d)", "e", expr);
   // `var' should be one of the dimensions of the polyhedron.
   }
   const dimension_type var_space_dim = var.space_dimension();
   if (space_dim < var_space_dim) {
     throw_dimension_incompatible("affine_image(v, e, d)", "v", var);
   }
   if (marked_empty()) {
     return;
   }
 
   if (expr.coefficient(var) != 0) {
     // The transformation is invertible:
     // minimality and saturators are preserved, so that
     // pending rows, if present, are correctly handled.
     if (generators_are_up_to_date()) {
       // Generator_System::affine_image() requires the third argument
       // to be a positive Coefficient.
       if (denominator > 0) {
         gen_sys.affine_image(var, expr, denominator);
       }
       else {
         gen_sys.affine_image(var, -expr, -denominator);
       }
     }
     if (constraints_are_up_to_date()) {
       // To build the inverse transformation,
       // after copying and negating `expr',
       // we exchange the roles of `expr[var_space_dim]' and `denominator'.
       Linear_Expression inverse;
       Coefficient_traits::const_reference c = expr.coefficient(var);
       if (c > 0) {
         inverse = -expr;
         inverse.set_coefficient(var, denominator);
         con_sys.affine_preimage(var, inverse, c);
       }
       else {
         // The new denominator is negative: we negate everything once
         // more, as Constraint_System::affine_preimage() requires the
         // third argument to be positive.
         inverse = expr;
         inverse.set_coefficient(var, -denominator);
         con_sys.affine_preimage(var, inverse, -c);
       }
     }
   }
   else {
     // The transformation is not invertible.
     // We need an up-to-date system of generators.
     if (has_something_pending()) {
       remove_pending_to_obtain_generators();
     }
     else if (!generators_are_up_to_date()) {
       minimize();
     }
     if (!marked_empty()) {
       // Generator_System::affine_image() requires the third argument
       // to be a positive Coefficient.
       if (denominator > 0) {
         gen_sys.affine_image(var, expr, denominator);
       }
       else {
         gen_sys.affine_image(var, -expr, -denominator);
       }
 
       clear_constraints_up_to_date();
       clear_generators_minimized();
       clear_sat_c_up_to_date();
       clear_sat_g_up_to_date();
     }
   }
   PPL_ASSERT_HEAVY(OK());
 }

void Parma_Polyhedra_Library::Polyhedron::affine_preimage	(	Variable	var,
		const Linear_Expression &	expr,
		Coefficient_traits::const_reference	denominator = `Coefficient_one()`
	)

Assigns to *this the affine preimage of *this under the function mapping variable var to the affine expression specified by expr and denominator.

Parameters

var	The variable to which the affine expression is substituted;
expr	The numerator of the affine expression;
denominator	The denominator of the affine expression (optional argument with default value 1).

Exceptions

std::invalid_argument Thrown if denominator is zero or if expr and *this are dimension-incompatible or if var is not a space dimension of *this.

When considering constraints of a polyhedron, the affine transformation

$\frac{\sum_{i=0}^{n-1} a_i x_i + b}{denominator},$

is assigned to var where expr is $\sum_{i=0}^{n-1} a_i x_i + b$ ( $b$ is the inhomogeneous term).

If generators are up-to-date, then the specialized function affine_image() is used (for the system of generators) and inverse transformation to reach the same result. To obtain the inverse transformation, we use the following observation.

Observation:

The affine transformation is invertible if the coefficient of var in this transformation (i.e. $a_\mathrm{var}$ ) is different from zero.
If the transformation is invertible, then we can write
$\mathrm{denominator} * {x'}_\mathrm{var} = \sum_{i = 0}^{n - 1} a_i x_i + b = a_\mathrm{var} x_\mathrm{var} + \sum_{i \neq \mathrm{var}} a_i x_i + b,$
, the inverse transformation is
$a_\mathrm{var} x_\mathrm{var} = \mathrm{denominator} * {x'}_\mathrm{var} - \sum_{i \neq j} a_i x_i - b.$
.

Then, if the transformation is invertible, all the entities that were up-to-date remain up-to-date. Otherwise only constraints remain up-to-date.

In other words, if $A$ is a $m \times n$ matrix representing the constraints of the polyhedron, $T$ is the affine transformation to apply to $P$ and

$P = \bigl\{\, \vect{x} = (x_0, \ldots, x_{n-1})^\mathrm{T} \bigm| A\vect{x} \geq \vect{0} \,\bigr\}.$

The resulting polyhedron is

$P' = \bigl\{\, \vect{x} = (x_0, \ldots, x_{n-1}))^\mathrm{T} \bigm| A'\vect{x} \geq \vect{0} \,\bigr\},$

where $A'$ is defined as follows:

${a'}_{ij} = \begin{cases} a_{ij} * \mathrm{denominator} + a_{i\mathrm{var}}*\mathrm{expr}[j] \quad \mathrm{for } j \neq \mathrm{var}; \\ \mathrm{expr}[\mathrm{var}] * a_{i\mathrm{var}}, \quad \text{for } j = \mathrm{var}. \end{cases}$

Definition at line 2833 of file Polyhedron_public.cc.

References c, Parma_Polyhedra_Library::Linear_Expression::coefficient(), Parma_Polyhedra_Library::inverse(), Parma_Polyhedra_Library::Linear_Expression::set_coefficient(), Parma_Polyhedra_Library::Variable::space_dimension(), and Parma_Polyhedra_Library::Linear_Expression::space_dimension().

                                                                {
   // The denominator cannot be zero.
   if (denominator == 0) {
     throw_invalid_argument("affine_preimage(v, e, d)", "d == 0");
   }
 
   // Dimension-compatibility checks.
   // The dimension of `expr' should not be greater than the dimension
   // of `*this'.
   if (space_dim < expr.space_dimension()) {
     throw_dimension_incompatible("affine_preimage(v, e, d)", "e", expr);
   // `var' should be one of the dimensions of the polyhedron.
   }
   const dimension_type var_space_dim = var.space_dimension();
   if (space_dim < var_space_dim) {
     throw_dimension_incompatible("affine_preimage(v, e, d)", "v", var);
   }
 
   if (marked_empty()) {
     return;
   }
 
   if (expr.coefficient(var) != 0) {
     // The transformation is invertible:
     // minimality and saturators are preserved.
     if (constraints_are_up_to_date()) {
       // Constraint_System::affine_preimage() requires the third argument
       // to be a positive Coefficient.
       if (denominator > 0) {
         con_sys.affine_preimage(var, expr, denominator);
       }
       else {
         con_sys.affine_preimage(var, -expr, -denominator);
       }
     }
     if (generators_are_up_to_date()) {
       // To build the inverse transformation,
       // after copying and negating `expr',
       // we exchange the roles of `expr[var_space_dim]' and `denominator'.
       Linear_Expression inverse;
       Coefficient_traits::const_reference c = expr.coefficient(var);
       if (c > 0) {
         inverse = -expr;
         inverse.set_coefficient(var, denominator);
         gen_sys.affine_image(var, inverse, c);
       }
       else {
         // The new denominator is negative:
         // we negate everything once more, as Generator_System::affine_image()
         // requires the third argument to be positive.
         inverse = expr;
         inverse.set_coefficient(var, -denominator);
         gen_sys.affine_image(var, inverse, -c);
       }
     }
   }
   else {
     // The transformation is not invertible.
     // We need an up-to-date system of constraints.
     if (has_something_pending()) {
       remove_pending_to_obtain_constraints();
     }
     else if (!constraints_are_up_to_date()) {
       minimize();
     }
     // Constraint_System::affine_preimage() requires the third argument
     // to be a positive Coefficient.
     if (denominator > 0) {
       con_sys.affine_preimage(var, expr, denominator);
     }
     else {
       con_sys.affine_preimage(var, -expr, -denominator);
     }
     // Generators, minimality and saturators are no longer valid.
     clear_generators_up_to_date();
     clear_constraints_minimized();
     clear_sat_c_up_to_date();
     clear_sat_g_up_to_date();
   }
   PPL_ASSERT_HEAVY(OK());
 }

void Parma_Polyhedra_Library::Polyhedron::ascii_dump ( ) const

Writes to std::cerr an ASCII representation of *this.

void Parma_Polyhedra_Library::Polyhedron::ascii_dump ( std::ostream & s ) const

Writes to s an ASCII representation of *this.

Definition at line 3965 of file Polyhedron_public.cc.

                                              {
   s << "space_dim " << space_dim << "\n";
   status.ascii_dump(s);
   s << "\ncon_sys ("
     << (constraints_are_up_to_date() ? "" : "not_")
     << "up-to-date)"
     << "\n";
   con_sys.ascii_dump(s);
   s << "\ngen_sys ("
     << (generators_are_up_to_date() ? "" : "not_")
     << "up-to-date)"
     << "\n";
   gen_sys.ascii_dump(s);
   s << "\nsat_c\n";
   sat_c.ascii_dump(s);
   s << "\nsat_g\n";
   sat_g.ascii_dump(s);
   s << "\n";
 }

bool Parma_Polyhedra_Library::Polyhedron::ascii_load ( std::istream & s )

Loads from s an ASCII representation (as produced by ascii_dump(std::ostream&) const) and sets *this accordingly. Returns true if successful, false otherwise.

Definition at line 3988 of file Polyhedron_public.cc.

                                        {
   std::string str;
 
   if (!(s >> str) || str != "space_dim") {
     return false;
   }
 
   if (!(s >> space_dim)) {
     return false;
   }
 
   if (!status.ascii_load(s)) {
     return false;
   }
 
   if (!(s >> str) || str != "con_sys") {
     return false;
   }
 
   if (!(s >> str) || (str != "(not_up-to-date)" && str != "(up-to-date)")) {
     return false;
   }
 
   if (!con_sys.ascii_load(s)) {
     return false;
   }
 
   if (!(s >> str) || str != "gen_sys") {
     return false;
   }
 
   if (!(s >> str) || (str != "(not_up-to-date)" && str != "(up-to-date)")) {
     return false;
   }
 
   if (!gen_sys.ascii_load(s)) {
     return false;
   }
 
   if (!(s >> str) || str != "sat_c") {
     return false;
   }
 
   if (!sat_c.ascii_load(s)) {
     return false;
   }
 
   if (!(s >> str) || str != "sat_g") {
     return false;
   }
 
   if (!sat_g.ascii_load(s)) {
     return false;
   }
 
   // Check invariants.
   PPL_ASSERT_HEAVY(OK());
   return true;
 }

bool Parma_Polyhedra_Library::Polyhedron::BFT00_poly_hull_assign_if_exact ( const Polyhedron & y )

protected

If the poly-hull of *this and y is exact it is assigned to *this and true is returned, otherwise false is returned.

Current implementation is based on (a variant of) Algorithm 8.1 in A. Bemporad, K. Fukuda, and F. D. Torrisi Convexity Recognition of the Union of Polyhedra Technical Report AUT00-13, ETH Zurich, 2000

Note: It is assumed that *this and y are topologically closed and dimension-compatible; if the assumption does not hold, the behavior is undefined.

Definition at line 2024 of file Polyhedron_nonpublic.cc.

                                                                   {
   // Declare a const reference to *this (to avoid accidental modifications).
   const Polyhedron& x = *this;
   // Private method: the caller must ensure the following.
   PPL_ASSERT(x.is_necessarily_closed());
   PPL_ASSERT(x.topology() == y.topology());
   PPL_ASSERT(x.space_dim == y.space_dim);
 
   // The zero-dim case is trivial.
   if (x.space_dim == 0) {
     upper_bound_assign(y);
     return true;
   }
   // If `x' or `y' is (known to be) empty, the convex union is exact.
   if (x.marked_empty()) {
     *this = y;
     return true;
   }
   else if (y.is_empty()) {
     return true;
   }
   else if (x.is_empty()) {
     *this = y;
     return true;
   }
 
   // Here both `x' and `y' are known to be non-empty.
 
   // Implementation based on Algorithm 8.1 (page 15) in [BemporadFT00TR],
   // generalized so as to also allow for unbounded polyhedra.
   // The extension to unbounded polyhedra is obtained by mimicking
   // what done in Algorithm 8.2 (page 19) with respect to
   // Algorithm 6.2 (page 13).
   // We also apply a couple of improvements (see steps 2.1, 3.1, 6.1, 7.1)
   // so as to quickly handle special cases and avoid the splitting
   // of equalities/lines into pairs of inequalities/rays.
 
   (void) x.minimize();
   (void) y.minimize();
   const Constraint_System& x_cs = x.con_sys;
   const Constraint_System& y_cs = y.con_sys;
   const Generator_System& x_gs = x.gen_sys;
   const Generator_System& y_gs = y.gen_sys;
   const dimension_type x_gs_num_rows = x_gs.num_rows();
   const dimension_type y_gs_num_rows = y_gs.num_rows();
 
   // Step 1: generators of `x' that are redundant in `y', and vice versa.
   std::vector<bool> x_gs_red_in_y(x_gs_num_rows, false);
   dimension_type num_x_gs_red_in_y = 0;
   for (dimension_type i = x_gs_num_rows; i-- > 0; ) {
     if (y.relation_with(x_gs[i]).implies(Poly_Gen_Relation::subsumes())) {
       x_gs_red_in_y[i] = true;
       ++num_x_gs_red_in_y;
     }
   }
   std::vector<bool> y_gs_red_in_x(y_gs_num_rows, false);
   dimension_type num_y_gs_red_in_x = 0;
   for (dimension_type i = y_gs_num_rows; i-- > 0; ) {
     if (x.relation_with(y_gs[i]).implies(Poly_Gen_Relation::subsumes())) {
       y_gs_red_in_x[i] = true;
       ++num_y_gs_red_in_x;
     }
   }
 
   // Step 2: if no redundant generator has been identified,
   // then the union is not convex. CHECKME: why?
   if (num_x_gs_red_in_y == 0 && num_y_gs_red_in_x == 0) {
     return false;
   }
 
   // Step 2.1: while at it, also perform quick inclusion tests.
   if (num_y_gs_red_in_x == y_gs_num_rows) {
     // `y' is included into `x': union is convex.
     return true;
   }
   if (num_x_gs_red_in_y == x_gs_num_rows) {
     // `x' is included into `y': union is convex.
     *this = y;
     return true;
   }
 
   // Here we know that `x' is not included in `y', and vice versa.
 
   // Step 3: constraints of `x' that are satisfied by `y', and vice versa.
   const dimension_type x_cs_num_rows = x_cs.num_rows();
   std::vector<bool> x_cs_red_in_y(x_cs_num_rows, false);
   for (dimension_type i = x_cs_num_rows; i-- > 0; ) {
     const Constraint& x_cs_i = x_cs[i];
     if (y.relation_with(x_cs_i).implies(Poly_Con_Relation::is_included())) {
       x_cs_red_in_y[i] = true;
     }
     else if (x_cs_i.is_equality()) {
       // Step 3.1: `x' has an equality not satisfied by `y':
       // union is not convex (recall that `y' does not contain `x').
       // NOTE: this would be false for NNC polyhedra.
       // Example: x = { A == 0 }, y = { 0 < A <= 1 }.
       return false;
     }
   }
   const dimension_type y_cs_num_rows = y_cs.num_rows();
   std::vector<bool> y_cs_red_in_x(y_cs_num_rows, false);
   for (dimension_type i = y_cs_num_rows; i-- > 0; ) {
     const Constraint& y_cs_i = y_cs[i];
     if (x.relation_with(y_cs_i).implies(Poly_Con_Relation::is_included())) {
       y_cs_red_in_x[i] = true;
     }
     else if (y_cs_i.is_equality()) {
       // Step 3.1: `y' has an equality not satisfied by `x':
       // union is not convex (see explanation above).
       return false;
     }
   }
 
   // Loop in steps 5-9: for each pair of non-redundant generators,
   // compute their "mid-point" and check if it is both in `x' and `y'.
 
   // Note: reasoning at the polyhedral cone level.
   Generator mid_g;
 
   for (dimension_type i = x_gs_num_rows; i-- > 0; ) {
     if (x_gs_red_in_y[i]) {
       continue;
     }
     const Generator& x_g = x_gs[i];
     const bool x_g_is_line = x_g.is_line_or_equality();
     for (dimension_type j = y_gs_num_rows; j-- > 0; ) {
       if (y_gs_red_in_x[j]) {
         continue;
       }
       const Generator& y_g = y_gs[j];
       const bool y_g_is_line = y_g.is_line_or_equality();
 
       // Step 6: compute mid_g = x_g + y_g.
       // NOTE: no need to actually compute the "mid-point",
       // since any strictly positive combination would do.
       mid_g = x_g;
       mid_g.expr += y_g.expr;
       // A zero ray is not a well formed generator.
       const bool illegal_ray
         = (mid_g.expr.inhomogeneous_term() == 0 && mid_g.expr.all_homogeneous_terms_are_zero());
       // A zero ray cannot be generated from a line: this holds
       // because x_row (resp., y_row) is not subsumed by y (resp., x).
       PPL_ASSERT(!(illegal_ray && (x_g_is_line || y_g_is_line)));
       if (illegal_ray) {
         continue;
       }
       mid_g.expr.normalize();
       if (x_g_is_line) {
         if (y_g_is_line) {
           // mid_row is a line too: sign normalization is needed.
           mid_g.sign_normalize();
         }
         else {
           // mid_row is a ray/point.
           mid_g.set_is_ray_or_point_or_inequality();
         }
       }
       PPL_ASSERT(mid_g.OK());
 
       // Step 7: check if mid_g is in the union of x and y.
       if (x.relation_with(mid_g) == Poly_Gen_Relation::nothing()
           && y.relation_with(mid_g) == Poly_Gen_Relation::nothing()) {
         return false;
       }
       // If either x_g or y_g is a line, we should use its
       // negation to produce another generator to be tested too.
       // NOTE: exclusive-or is meant.
       if (!x_g_is_line && y_g_is_line) {
         // Step 6.1: (re-)compute mid_row = x_g - y_g.
         mid_g = x_g;
         mid_g.expr -= y_g.expr;
         mid_g.expr.normalize();
         PPL_ASSERT(mid_g.OK());
         // Step 7.1: check if mid_g is in the union of x and y.
         if (x.relation_with(mid_g) == Poly_Gen_Relation::nothing()
             && y.relation_with(mid_g) == Poly_Gen_Relation::nothing()) {
           return false;
         }
       }
       else if (x_g_is_line && !y_g_is_line) {
         // Step 6.1: (re-)compute mid_row = - x_row + y_row.
         mid_g = y_g;
         mid_g.expr -= x_g.expr;
         mid_g.expr.normalize();
         PPL_ASSERT(mid_g.OK());
         // Step 7.1: check if mid_g is in the union of x and y.
         if (x.relation_with(mid_g) == Poly_Gen_Relation::nothing()
             && y.relation_with(mid_g) == Poly_Gen_Relation::nothing()) {
           return false;
         }
       }
     }
   }
 
   // Here we know that the union of x and y is convex.
   // TODO: exploit knowledge on the cardinality of non-redundant
   // constraints/generators to improve the convex-hull computation.
   // Using generators allows for exploiting incrementality.
   for (dimension_type j = 0; j < y_gs_num_rows; ++j) {
     if (!y_gs_red_in_x[j]) {
       add_generator(y_gs[j]);
     }
   }
   PPL_ASSERT_HEAVY(OK());
   return true;
 }

bool Parma_Polyhedra_Library::Polyhedron::BHRZ03_combining_constraints	(	const Polyhedron &	y,
		const BHRZ03_Certificate &	y_cert,
		const Polyhedron &	H79,
		const Constraint_System &	x_minus_H79_cs
	)

private

Definition at line 399 of file Polyhedron_widenings.cc.

Referenced by BHRZ03_widening_assign().

                                                                         {
   Polyhedron& x = *this;
   // It is assumed that `y <= x <= H79'.
   PPL_ASSERT(x.topology() == y.topology()
          && x.topology() == H79.topology()
          && x.topology() == x_minus_H79_cs.topology());
   PPL_ASSERT(x.space_dim == y.space_dim
          && x.space_dim == H79.space_dim
          && x.space_dim == x_minus_H79_cs.space_dimension());
   PPL_ASSERT(!x.marked_empty() && !x.has_something_pending()
          && x.constraints_are_minimized() && x.generators_are_minimized());
   PPL_ASSERT(!y.marked_empty() && !y.has_something_pending()
          && y.constraints_are_minimized() && y.generators_are_minimized());
   PPL_ASSERT(!H79.marked_empty() && !H79.has_something_pending()
          && H79.constraints_are_minimized() && H79.generators_are_minimized());
 
   // We will choose from `x_minus_H79_cs' many subsets of constraints,
   // that will be collected (one at a time) in `combining_cs'.
   // For each group collected, we compute an average constraint,
   // that will be stored in `new_cs'.
 
   // There is no point in applying this technique when `x_minus_H79_cs'
   // has one constraint at most (no ``new'' constraint can be computed).
   const dimension_type x_minus_H79_cs_num_rows = x_minus_H79_cs.num_rows();
   if (x_minus_H79_cs_num_rows <= 1) {
     return false;
   }
 
   const Topology topol = x.topology();
   Constraint_System combining_cs(topol);
   Constraint_System new_cs(topol);
 
   // Consider the points that belong to both `x.gen_sys' and `y.gen_sys'.
   // For NNC polyhedra, the role of points is played by closure points.
   const bool closed = x.is_necessarily_closed();
   for (dimension_type i = y.gen_sys.num_rows(); i-- > 0; ) {
     const Generator& g = y.gen_sys[i];
     if ((g.is_point() && closed) || (g.is_closure_point() && !closed)) {
       // If in `H79.con_sys' there is already an inequality constraint
       // saturating this point, then there is no need to produce another
       // constraint.
       bool lies_on_the_boundary_of_H79 = false;
       const Constraint_System& H79_cs = H79.con_sys;
       for (dimension_type j = H79_cs.num_rows(); j-- > 0; ) {
         const Constraint& c = H79_cs[j];
         if (c.is_inequality() && Scalar_Products::sign(c, g) == 0) {
           lies_on_the_boundary_of_H79 = true;
           break;
         }
       }
       if (lies_on_the_boundary_of_H79) {
         continue;
       }
 
       // Consider all the constraints in `x_minus_H79_cs'
       // that are saturated by the point `g'.
       combining_cs.clear();
       for (dimension_type j = x_minus_H79_cs_num_rows; j-- > 0; ) {
         const Constraint& c = x_minus_H79_cs[j];
         if (Scalar_Products::sign(c, g) == 0) {
           combining_cs.insert(c);
         }
       }
       // Build a new constraint by combining all the chosen constraints.
       const dimension_type combining_cs_num_rows = combining_cs.num_rows();
       if (combining_cs_num_rows > 0) {
         if (combining_cs_num_rows == 1) {
           // No combination is needed.
           new_cs.insert(combining_cs[0]);
         }
         else {
           Linear_Expression e(0);
           bool strict_inequality = false;
           for (dimension_type h = combining_cs_num_rows; h-- > 0; ) {
             if (combining_cs[h].is_strict_inequality()) {
               strict_inequality = true;
             }
             e += Linear_Expression(combining_cs[h].expression());
           }
 
           if (!e.all_homogeneous_terms_are_zero()) {
             if (strict_inequality) {
               new_cs.insert(e > 0);
             }
             else {
               new_cs.insert(e >= 0);
             }
           }
         }
       }
     }
   }
 
   // If none of the collected constraints strictly intersects `H79',
   // then the technique was unsuccessful.
   bool improves_upon_H79 = false;
   const Poly_Con_Relation si = Poly_Con_Relation::strictly_intersects();
   for (dimension_type i = new_cs.num_rows(); i-- > 0; ) {
     if (H79.relation_with(new_cs[i]) == si) {
       improves_upon_H79 = true;
       break;
     }
   }
   if (!improves_upon_H79) {
     return false;
   }
 
   // The resulting polyhedron is obtained by adding the constraints
   // in `new_cs' to polyhedron `H79'.
   Polyhedron result = H79;
   result.add_recycled_constraints(new_cs);
   // Force minimization.
   result.minimize();
 
   // Check for stabilization with respect to `y_cert' and improvement
   // over `H79'.
   if (y_cert.is_stabilizing(result) && !result.contains(H79)) {
     // The technique was successful.
     x.m_swap(result);
     PPL_ASSERT_HEAVY(x.OK(true));
     return true;
   }
   else {
     // The technique was unsuccessful.
     return false;
   }
 }

bool Parma_Polyhedra_Library::Polyhedron::BHRZ03_evolving_points	(	const Polyhedron &	y,
		const BHRZ03_Certificate &	y_cert,
		const Polyhedron &	H79
	)

private

Definition at line 531 of file Polyhedron_widenings.cc.

References add_recycled_generators(), Parma_Polyhedra_Library::compare(), constraints_are_minimized(), contains(), gen_sys, generators_are_minimized(), has_something_pending(), intersection_assign(), Parma_Polyhedra_Library::Generator::is_closure_point(), is_necessarily_closed(), Parma_Polyhedra_Library::Generator::is_point(), Parma_Polyhedra_Library::BHRZ03_Certificate::is_stabilizing(), Parma_Polyhedra_Library::Generator::linear_combine(), m_swap(), marked_empty(), minimize(), Parma_Polyhedra_Library::Poly_Gen_Relation::nothing(), Parma_Polyhedra_Library::Generator_System::num_rows(), OK(), relation_with(), space_dim, and topology().

Referenced by BHRZ03_widening_assign().

                                                                {
   Polyhedron& x = *this;
   // It is assumed that `y <= x <= H79'.
   PPL_ASSERT(x.topology() == y.topology()
          && x.topology() == H79.topology());
   PPL_ASSERT(x.space_dim == y.space_dim
          && x.space_dim == H79.space_dim);
   PPL_ASSERT(!x.marked_empty() && !x.has_something_pending()
          && x.constraints_are_minimized() && x.generators_are_minimized());
   PPL_ASSERT(!y.marked_empty() && !y.has_something_pending()
          && y.constraints_are_minimized() && y.generators_are_minimized());
   PPL_ASSERT(!H79.marked_empty() && !H79.has_something_pending()
          && H79.constraints_are_minimized() && H79.generators_are_minimized());
 
   // For each point in `x.gen_sys' that is not in `y',
   // this technique tries to identify a set of rays that:
   //  - are included in polyhedron `H79';
   //  - when added to `y' will subsume the point.
   Generator_System candidate_rays;
 
   const dimension_type x_gen_sys_num_rows = x.gen_sys.num_rows();
   const dimension_type y_gen_sys_num_rows = y.gen_sys.num_rows();
   const bool closed = x.is_necessarily_closed();
   for (dimension_type i = x_gen_sys_num_rows; i-- > 0; ) {
     const Generator& g1 = x.gen_sys[i];
     // For C polyhedra, we choose a point of `x.gen_sys'
     // that is not included in `y'.
     // In the case of NNC polyhedra, we can restrict attention to
     // closure points (considering also points will only add redundancy).
     if (((g1.is_point() && closed) || (g1.is_closure_point() && !closed))
         && y.relation_with(g1) == Poly_Gen_Relation::nothing()) {
       // For each point (resp., closure point) `g2' in `y.gen_sys',
       // where `g1' and `g2' are different,
       // build the candidate ray `g1 - g2'.
       for (dimension_type j = y_gen_sys_num_rows; j-- > 0; ) {
         const Generator& g2 = y.gen_sys[j];
         if ((g2.is_point() && closed)
             || (g2.is_closure_point() && !closed)) {
           PPL_ASSERT(compare(g1, g2) != 0);
           Generator ray_from_g2_to_g1 = g1;
           ray_from_g2_to_g1.linear_combine(g2, 0);
           candidate_rays.insert(ray_from_g2_to_g1);
         }
       }
     }
   }
 
   // Be non-intrusive.
   Polyhedron result = x;
   result.add_recycled_generators(candidate_rays);
   result.intersection_assign(H79);
   // Force minimization.
   result.minimize();
 
   // Check for stabilization with respect to `y_cert' and improvement
   // over `H79'.
   if (y_cert.is_stabilizing(result) && !result.contains(H79)) {
     // The technique was successful.
     x.m_swap(result);
     PPL_ASSERT_HEAVY(x.OK(true));
     return true;
   }
   else  {
     // The technique was unsuccessful.
     return false;
   }
 }

bool Parma_Polyhedra_Library::Polyhedron::BHRZ03_evolving_rays	(	const Polyhedron &	y,
		const BHRZ03_Certificate &	y_cert,
		const Polyhedron &	H79
	)

private

Definition at line 679 of file Polyhedron_widenings.cc.

Referenced by BHRZ03_widening_assign().

                                                              {
   Polyhedron& x = *this;
   // It is assumed that `y <= x <= H79'.
   PPL_ASSERT(x.topology() == y.topology()
          && x.topology() == H79.topology());
   PPL_ASSERT(x.space_dim == y.space_dim
          && x.space_dim == H79.space_dim);
   PPL_ASSERT(!x.marked_empty() && !x.has_something_pending()
          && x.constraints_are_minimized() && x.generators_are_minimized());
   PPL_ASSERT(!y.marked_empty() && !y.has_something_pending()
          && y.constraints_are_minimized() && y.generators_are_minimized());
   PPL_ASSERT(!H79.marked_empty() && !H79.has_something_pending()
          && H79.constraints_are_minimized() && H79.generators_are_minimized());
 
   const dimension_type x_gen_sys_num_rows = x.gen_sys.num_rows();
   const dimension_type y_gen_sys_num_rows = y.gen_sys.num_rows();
 
   // Candidate rays are kept in a temporary generator system.
   Generator_System candidate_rays;
   for (dimension_type i = x_gen_sys_num_rows; i-- > 0; ) {
     const Generator& x_g = x.gen_sys[i];
     // We choose a ray of `x' that does not belong to `y'.
     if (x_g.is_ray() && y.relation_with(x_g) == Poly_Gen_Relation::nothing()) {
       for (dimension_type j = y_gen_sys_num_rows; j-- > 0; ) {
         const Generator& y_g = y.gen_sys[j];
         if (y_g.is_ray()) {
           Generator new_ray(x_g);
           // Modify `new_ray' according to the evolution of `x_g' with
           // respect to `y_g'.
           modify_according_to_evolution(new_ray.expr, x_g.expr, y_g.expr);
           PPL_ASSERT(new_ray.OK());
           candidate_rays.insert(new_ray);
         }
       }
     }
   }
 
   // If there are no candidate rays, we cannot obtain stabilization.
   if (candidate_rays.has_no_rows()) {
     return false;
   }
 
   // Be non-intrusive.
   Polyhedron result = x;
   result.add_recycled_generators(candidate_rays);
   result.intersection_assign(H79);
   // Force minimization.
   result.minimize();
 
   // Check for stabilization with respect to `y' and improvement over `H79'.
   if (y_cert.is_stabilizing(result) && !result.contains(H79)) {
     // The technique was successful.
     x.m_swap(result);
     PPL_ASSERT_HEAVY(x.OK(true));
     return true;
   }
   else {
     // The technique was unsuccessful.
     return false;
   }
 }

void Parma_Polyhedra_Library::Polyhedron::BHRZ03_widening_assign	(	const Polyhedron &	y,
		unsigned *	tp = `0`
	)

Assigns to *this the result of computing the BHRZ03-widening between *this and y.

Parameters

y	A polyhedron that must be contained in `*this`;
tp	An optional pointer to an unsigned variable storing the number of available tokens (to be used when applying the widening with tokens delay technique).

Exceptions

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

Definition at line 744 of file Polyhedron_widenings.cc.

References BHRZ03_combining_constraints(), BHRZ03_evolving_points(), BHRZ03_evolving_rays(), contains(), Parma_Polyhedra_Library::Constraint_System::has_no_rows(), Parma_Polyhedra_Library::BHRZ03_Certificate::is_stabilizing(), m_swap(), marked_empty(), minimize(), OK(), select_H79_constraints(), space_dim, topology(), and Parma_Polyhedra_Library::UNIVERSE.

Referenced by limited_BHRZ03_extrapolation_assign().

                                                                        {
   Polyhedron& x = *this;
   // Topology compatibility check.
   if (x.topology() != y.topology()) {
     throw_topology_incompatible("BHRZ03_widening_assign(y)", "y", y);
   }
   // Dimension-compatibility check.
   if (x.space_dim != y.space_dim) {
     throw_dimension_incompatible("BHRZ03_widening_assign(y)", "y", y);
   }
 
   // Assume `y' is contained in or equal to `x'.
   PPL_EXPECT_HEAVY(copy_contains(x, y));
 
   // If any argument is zero-dimensional or empty,
   // the BHRZ03-widening behaves as the identity function.
   if (x.space_dim == 0 || x.marked_empty() || y.marked_empty()) {
     return;
   }
 
   // `y.con_sys' and `y.gen_sys' should be in minimal form.
   if (!y.minimize()) {
     // `y' is empty: the result is `x'.
     return;
   }
   // `x.con_sys' and `x.gen_sys' should be in minimal form.
   x.minimize();
 
   // Compute certificate info for polyhedron `y'.
   const BHRZ03_Certificate y_cert(y);
 
   // If the iteration is stabilizing, the resulting polyhedron is `x'.
   // At this point, also check if the two polyhedra are the same
   // (exploiting the knowledge that `y <= x').
   if (y_cert.is_stabilizing(x) || y.contains(x)) {
     PPL_ASSERT_HEAVY(OK());
     return;
   }
 
   // Here the iteration is not immediately stabilizing.
   // If we are using the widening-with-tokens technique and
   // there are tokens available, use one of them and return `x'.
   if (tp != 0 && *tp > 0) {
     --(*tp);
     PPL_ASSERT_HEAVY(OK());
     return;
   }
 
   // Copy into `H79_cs' the constraints that are common to `x' and `y',
   // according to the definition of the H79 widening.
   // The other ones are copied into `x_minus_H79_cs'.
   const Topology topol = x.topology();
   Constraint_System H79_cs(topol);
   Constraint_System x_minus_H79_cs(topol);
   x.select_H79_constraints(y, H79_cs, x_minus_H79_cs);
 
   // We cannot have selected all of the rows, since otherwise
   // the iteration should have been immediately stabilizing.
   PPL_ASSERT(!x_minus_H79_cs.has_no_rows());
   // Be careful to obtain the right space dimension
   // (because `H79_cs' may be empty).
   Polyhedron H79(topol, x.space_dim, UNIVERSE);
   H79.add_recycled_constraints(H79_cs);
   // Force minimization.
   H79.minimize();
 
   // NOTE: none of the following widening heuristics is intrusive:
   // they will modify `x' only when returning successfully.
   if (x.BHRZ03_combining_constraints(y, y_cert, H79, x_minus_H79_cs)) {
     return;
   }
 
   PPL_ASSERT_HEAVY(H79.OK() && x.OK() && y.OK());
 
   if (x.BHRZ03_evolving_points(y, y_cert, H79)) {
     return;
   }
 
   PPL_ASSERT_HEAVY(H79.OK() && x.OK() && y.OK());
 
   if (x.BHRZ03_evolving_rays(y, y_cert, H79)) {
     return;
   }
 
   PPL_ASSERT_HEAVY(H79.OK() && x.OK() && y.OK());
 
   // No previous technique was successful: fall back to the H79 widening.
   x.m_swap(H79);
   PPL_ASSERT_HEAVY(x.OK(true));
 
   // The H79 widening is always stabilizing.
   PPL_ASSERT(y_cert.is_stabilizing(x));
 }

bool Parma_Polyhedra_Library::Polyhedron::BHZ09_C_poly_hull_assign_if_exact ( const Polyhedron & y )

protected

Definition at line 1540 of file Polyhedron_nonpublic.cc.

References affine_dimension(), con_sys, gen_sys, Parma_Polyhedra_Library::Poly_Con_Relation::implies(), is_empty(), Parma_Polyhedra_Library::Poly_Con_Relation::is_included(), is_included_in(), is_necessarily_closed(), minimize(), Parma_Polyhedra_Library::Generator_System::num_rows(), Parma_Polyhedra_Library::Constraint_System::num_rows(), relation_with(), sat_g, sat_g_is_up_to_date(), Parma_Polyhedra_Library::Bit_Row::set(), Parma_Polyhedra_Library::Bit_Row::set_until(), space_dim, Parma_Polyhedra_Library::Poly_Gen_Relation::subsumes(), Parma_Polyhedra_Library::Bit_Row::union_assign(), and update_sat_g().

Referenced by BHZ09_poly_hull_assign_if_exact().

                                                                     {
   Polyhedron& x = *this;
   // Private method: the caller must ensure the following.
   PPL_ASSERT(x.is_necessarily_closed() && y.is_necessarily_closed());
   PPL_ASSERT(x.space_dim > 0 && x.space_dim == y.space_dim);
   PPL_ASSERT(!x.is_empty() && !y.is_empty());
 
   // Minimization is not really required, but it is probably the best
   // way of getting constraints, generators and saturation matrices
   // up-to-date.  Minimization it also removes redundant
   // constraints/generators.
   (void) x.minimize();
   (void) y.minimize();
 
   // Handle a special case: for topologically closed polyhedra P and Q,
   // if the affine dimension of P is greater than that of Q, then
   // their upper bound is exact if and only if P includes Q.
   const dimension_type x_affine_dim = x.affine_dimension();
   const dimension_type y_affine_dim = y.affine_dimension();
   if (x_affine_dim > y_affine_dim) {
     return y.is_included_in(x);
   }
   else if (x_affine_dim < y_affine_dim) {
     if (x.is_included_in(y)) {
       x = y;
       return true;
     }
     else {
       return false;
     }
   }
 
   const Constraint_System& x_cs = x.con_sys;
   const Generator_System& x_gs = x.gen_sys;
   const Generator_System& y_gs = y.gen_sys;
   const dimension_type x_gs_num_rows = x_gs.num_rows();
   const dimension_type y_gs_num_rows = y_gs.num_rows();
 
   // Step 1: generators of `x' that are redundant in `y', and vice versa.
   Bit_Row x_gs_red_in_y;
   dimension_type num_x_gs_red_in_y = 0;
   for (dimension_type i = x_gs_num_rows; i-- > 0; ) {
     if (y.relation_with(x_gs[i]).implies(Poly_Gen_Relation::subsumes())) {
       x_gs_red_in_y.set(i);
       ++num_x_gs_red_in_y;
     }
   }
 
   Bit_Row y_gs_red_in_x;
   dimension_type num_y_gs_red_in_x = 0;
   for (dimension_type i = y_gs_num_rows; i-- > 0; ) {
     if (x.relation_with(y_gs[i]).implies(Poly_Gen_Relation::subsumes())) {
       y_gs_red_in_x.set(i);
       ++num_y_gs_red_in_x;
     }
   }
   // Step 2: filter away special cases.
 
   // Step 2.1: inclusion tests.
   if (num_y_gs_red_in_x == y_gs_num_rows) {
     // `y' is included into `x': upper bound `x' is exact.
     return true;
   }
   if (num_x_gs_red_in_y == x_gs_num_rows) {
     // `x' is included into `y': upper bound `y' is exact.
     x = y;
     return true;
   }
 
   // Step 2.2: if no generator of `x' is redundant for `y', then
   // (as by 2.1 there exists a constraint of `x' non-redundant for `y')
   // the upper bound is not exact; the same if exchanging `x' and `y'.
   if (num_x_gs_red_in_y == 0 || num_y_gs_red_in_x == 0) {
     return false;
   }
 
   // Step 3: see if `x' has a non-redundant constraint `c_x' that is not
   // satisfied by `y' and a non-redundant generator in `y' (see Step 1)
   // saturating `c_x'. If so, the upper bound is not exact.
 
   // Make sure the saturation matrix for `x' is up to date.
   // Any sat matrix would do: we choose `sat_g' because it matches
   // the two nested loops (constraints on rows and generators on columns).
   if (!x.sat_g_is_up_to_date()) {
     x.update_sat_g();
   }
   const Bit_Matrix& x_sat = x.sat_g;
 
   Bit_Row all_ones;
   all_ones.set_until(x_gs_num_rows);
   Bit_Row row_union;
   for (dimension_type i = x_cs.num_rows(); i-- > 0; ) {
     const bool included
       = y.relation_with(x_cs[i]).implies(Poly_Con_Relation::is_included());
     if (!included) {
       row_union.union_assign(x_gs_red_in_y, x_sat[i]);
       if (row_union != all_ones) {
         return false;
       }
     }
   }
 
   // Here we know that the upper bound is exact: compute it.
   for (dimension_type j = y_gs_num_rows; j-- > 0; ) {
     if (!y_gs_red_in_x[j]) {
       add_generator(y_gs[j]);
     }
   }
 
   PPL_ASSERT_HEAVY(OK());
   return true;
 }

bool Parma_Polyhedra_Library::Polyhedron::BHZ09_NNC_poly_hull_assign_if_exact ( const Polyhedron & y )

protected

Definition at line 1654 of file Polyhedron_nonpublic.cc.

Referenced by BHZ09_poly_hull_assign_if_exact().

                                                                       {
   const Polyhedron& x = *this;
   // Private method: the caller must ensure the following.
   PPL_ASSERT(!x.is_necessarily_closed() && !y.is_necessarily_closed());
   PPL_ASSERT(x.space_dim > 0 && x.space_dim == y.space_dim);
   PPL_ASSERT(!x.is_empty() && !y.is_empty());
 
   // Minimization is not really required, but it is probably the best
   // way of getting constraints, generators and saturation matrices
   // up-to-date.  Minimization also removes redundant
   // constraints/generators.
   (void) x.minimize();
   (void) y.minimize();
 
   const Generator_System& x_gs = x.gen_sys;
   const Generator_System& y_gs = y.gen_sys;
   const dimension_type x_gs_num_rows = x_gs.num_rows();
   const dimension_type y_gs_num_rows = y_gs.num_rows();
 
   // Compute generators of `x' that are non-redundant in `y' ...
   Bit_Row x_gs_non_redundant_in_y;
   Bit_Row x_points_non_redundant_in_y;
   Bit_Row x_closure_points;
   dimension_type num_x_gs_non_redundant_in_y = 0;
   for (dimension_type i = x_gs_num_rows; i-- > 0; ) {
     const Generator& x_gs_i = x_gs[i];
     if (x_gs_i.is_closure_point()) {
       x_closure_points.set(i);
     }
     if (y.relation_with(x_gs[i]).implies(Poly_Gen_Relation::subsumes())) {
       continue;
     }
     x_gs_non_redundant_in_y.set(i);
     ++num_x_gs_non_redundant_in_y;
     if (x_gs_i.is_point()) {
       x_points_non_redundant_in_y.set(i);
     }
   }
 
   // If `x' is included into `y', the upper bound `y' is exact.
   if (num_x_gs_non_redundant_in_y == 0) {
     *this = y;
     return true;
   }
 
   // ... and vice versa, generators of `y' that are non-redundant in `x'.
   Bit_Row y_gs_non_redundant_in_x;
   Bit_Row y_points_non_redundant_in_x;
   Bit_Row y_closure_points;
   dimension_type num_y_gs_non_redundant_in_x = 0;
   for (dimension_type i = y_gs_num_rows; i-- > 0; ) {
     const Generator& y_gs_i = y_gs[i];
     if (y_gs_i.is_closure_point()) {
       y_closure_points.set(i);
     }
     if (x.relation_with(y_gs_i).implies(Poly_Gen_Relation::subsumes())) {
       continue;
     }
     y_gs_non_redundant_in_x.set(i);
     ++num_y_gs_non_redundant_in_x;
     if (y_gs_i.is_point()) {
       y_points_non_redundant_in_x.set(i);
     }
   }
 
   // If `y' is included into `x', the upper bound `x' is exact.
   if (num_y_gs_non_redundant_in_x == 0) {
     return true;
   }
 
   Bit_Row x_non_points_non_redundant_in_y;
   x_non_points_non_redundant_in_y
     .difference_assign(x_gs_non_redundant_in_y,
                        x_points_non_redundant_in_y);
 
   const Constraint_System& x_cs = x.con_sys;
   const Constraint_System& y_cs = y.con_sys;
   const dimension_type x_cs_num_rows = x_cs.num_rows();
   const dimension_type y_cs_num_rows = y_cs.num_rows();
 
   // Filter away the points of `x_gs' that would be redundant
   // in the topological closure of `y'.
   Bit_Row x_points_non_redundant_in_y_closure;
   for (dimension_type i = x_points_non_redundant_in_y.first();
        i != C_Integer<unsigned long>::max;
        i = x_points_non_redundant_in_y.next(i)) {
     const Generator& x_p = x_gs[i];
     PPL_ASSERT(x_p.is_point());
     // NOTE: we cannot use Constraint_System::relation_with()
     // as we need to treat strict inequalities as if they were nonstrict.
     for (dimension_type j = y_cs_num_rows; j-- > 0; ) {
       const Constraint& y_c = y_cs[j];
       const int sp_sign = Scalar_Products::reduced_sign(y_c, x_p);
       if (sp_sign < 0 || (y_c.is_equality() && sp_sign > 0)) {
         x_points_non_redundant_in_y_closure.set(i);
         break;
       }
     }
   }
 
   // Make sure the saturation matrix for `x' is up to date.
   // Any sat matrix would do: we choose `sat_g' because it matches
   // the two nested loops (constraints on rows and generators on columns).
   if (!x.sat_g_is_up_to_date()) {
     x.update_sat_g();
   }
   const Bit_Matrix& x_sat = x.sat_g;
 
   Bit_Row x_cs_condition_3;
   Bit_Row x_gs_condition_3;
   Bit_Row all_ones;
   all_ones.set_until(x_gs_num_rows);
   Bit_Row saturators;
   Bit_Row tmp_set;
   for (dimension_type i = x_cs_num_rows; i-- > 0; ) {
     const Constraint& x_c = x_cs[i];
     // Skip constraint if it is not violated by `y'.
     if (y.relation_with(x_c).implies(Poly_Con_Relation::is_included())) {
       continue;
     }
     saturators.difference_assign(all_ones, x_sat[i]);
     // Check condition 1.
     tmp_set.intersection_assign(x_non_points_non_redundant_in_y, saturators);
     if (!tmp_set.empty()) {
       return false;
     }
     if (x_c.is_strict_inequality()) {
       // Postpone check for condition 3.
       x_cs_condition_3.set(i);
       tmp_set.intersection_assign(x_closure_points, saturators);
       x_gs_condition_3.union_assign(x_gs_condition_3, tmp_set);
     }
     else {
       // Check condition 2.
       tmp_set.intersection_assign(x_points_non_redundant_in_y_closure,
                                   saturators);
       if (!tmp_set.empty()) {
         return false;
       }
     }
   }
 
   // Now exchange the roles of `x' and `y'
   // (the statement of the NNC theorem in BHZ09 is symmetric).
 
   Bit_Row y_non_points_non_redundant_in_x;
   y_non_points_non_redundant_in_x
     .difference_assign(y_gs_non_redundant_in_x,
                        y_points_non_redundant_in_x);
 
   // Filter away the points of `y_gs' that would be redundant
   // in the topological closure of `x'.
   Bit_Row y_points_non_redundant_in_x_closure;
   for (dimension_type i = y_points_non_redundant_in_x.first();
        i != C_Integer<unsigned long>::max;
        i = y_points_non_redundant_in_x.next(i)) {
     const Generator& y_p = y_gs[i];
     PPL_ASSERT(y_p.is_point());
     // NOTE: we cannot use Constraint_System::relation_with()
     // as we need to treat strict inequalities as if they were nonstrict.
     for (dimension_type j = x_cs_num_rows; j-- > 0; ) {
       const Constraint& x_c = x_cs[j];
       const int sp_sign = Scalar_Products::reduced_sign(x_c, y_p);
       if (sp_sign < 0 || (x_c.is_equality() && sp_sign > 0)) {
         y_points_non_redundant_in_x_closure.set(i);
         break;
       }
     }
   }
 
   // Make sure the saturation matrix `sat_g' for `y' is up to date.
   if (!y.sat_g_is_up_to_date()) {
     y.update_sat_g();
   }
   const Bit_Matrix& y_sat = y.sat_g;
 
   Bit_Row y_cs_condition_3;
   Bit_Row y_gs_condition_3;
   all_ones.clear();
   all_ones.set_until(y_gs_num_rows);
   for (dimension_type i = y_cs_num_rows; i-- > 0; ) {
     const Constraint& y_c = y_cs[i];
     // Skip constraint if it is not violated by `x'.
     if (x.relation_with(y_c).implies(Poly_Con_Relation::is_included())) {
       continue;
     }
     saturators.difference_assign(all_ones, y_sat[i]);
     // Check condition 1.
     tmp_set.intersection_assign(y_non_points_non_redundant_in_x, saturators);
     if (!tmp_set.empty()) {
       return false;
     }
     if (y_c.is_strict_inequality()) {
       // Postpone check for condition 3.
       y_cs_condition_3.set(i);
       tmp_set.intersection_assign(y_closure_points, saturators);
       y_gs_condition_3.union_assign(y_gs_condition_3, tmp_set);
     }
     else {
       // Check condition 2.
       tmp_set.intersection_assign(y_points_non_redundant_in_x_closure,
                                   saturators);
       if (!tmp_set.empty()) {
         return false;
       }
     }
   }
 
   // Now considering condition 3.
 
   if (x_cs_condition_3.empty() && y_cs_condition_3.empty()) {
     // No test for condition 3 is needed.
     // The hull is exact: compute it.
     for (dimension_type j = y_gs_num_rows; j-- > 0; ) {
       if (y_gs_non_redundant_in_x[j]) {
         add_generator(y_gs[j]);
       }
     }
     return true;
   }
 
   // We have anyway to compute the upper bound and its constraints too.
   Polyhedron ub(x);
   for (dimension_type j = y_gs_num_rows; j-- > 0; ) {
     if (y_gs_non_redundant_in_x[j]) {
       ub.add_generator(y_gs[j]);
     }
   }
   (void) ub.minimize();
   PPL_ASSERT(!ub.is_empty());
 
   // NOTE: the following computation of x_gs_condition_3_not_in_y
   // (resp., y_gs_condition_3_not_in_x) is not required for correctness.
   // It is done so as to later apply a speculative test
   // (i.e., a non-conclusive but computationally lighter test).
 
   // Filter away from `x_gs_condition_3' those closure points
   // that, when considered as points, would belong to `y',
   // i.e., those that violate no strict constraint in `y_cs'.
   Bit_Row x_gs_condition_3_not_in_y;
   for (dimension_type i = y_cs_num_rows; i-- > 0; ) {
     const Constraint& y_c = y_cs[i];
     if (y_c.is_strict_inequality()) {
       for (dimension_type j = x_gs_condition_3.first();
            j != C_Integer<unsigned long>::max; j = x_gs_condition_3.next(j)) {
         const Generator& x_cp = x_gs[j];
         PPL_ASSERT(x_cp.is_closure_point());
         const int sp_sign = Scalar_Products::reduced_sign(y_c, x_cp);
         PPL_ASSERT(sp_sign >= 0);
         if (sp_sign == 0) {
           x_gs_condition_3.clear(j);
           x_gs_condition_3_not_in_y.set(j);
         }
       }
       if (x_gs_condition_3.empty()) {
         break;
       }
     }
   }
   // Symmetrically, filter away from `y_gs_condition_3' those
   // closure points that, when considered as points, would belong to `x',
   // i.e., those that violate no strict constraint in `x_cs'.
   Bit_Row y_gs_condition_3_not_in_x;
   for (dimension_type i = x_cs_num_rows; i-- > 0; ) {
     if (x_cs[i].is_strict_inequality()) {
       const Constraint& x_c = x_cs[i];
       for (dimension_type j = y_gs_condition_3.first();
            j != C_Integer<unsigned long>::max; j = y_gs_condition_3.next(j)) {
         const Generator& y_cp = y_gs[j];
         PPL_ASSERT(y_cp.is_closure_point());
         const int sp_sign = Scalar_Products::reduced_sign(x_c, y_cp);
         PPL_ASSERT(sp_sign >= 0);
         if (sp_sign == 0) {
           y_gs_condition_3.clear(j);
           y_gs_condition_3_not_in_x.set(j);
         }
       }
       if (y_gs_condition_3.empty()) {
         break;
       }
     }
   }
 
   // NOTE: here we apply the speculative test.
   // Check if there exists a closure point in `x_gs_condition_3_not_in_y'
   // or `y_gs_condition_3_not_in_x' that belongs (as point) to the hull.
   // If so, the hull is not exact.
   const Constraint_System& ub_cs = ub.constraints();
   for (dimension_type i = ub_cs.num_rows(); i-- > 0; ) {
     if (ub_cs[i].is_strict_inequality()) {
       const Constraint& ub_c = ub_cs[i];
       for (dimension_type j = x_gs_condition_3_not_in_y.first();
            j != C_Integer<unsigned long>::max;
            j = x_gs_condition_3_not_in_y.next(j)) {
         const Generator& x_cp = x_gs[j];
         PPL_ASSERT(x_cp.is_closure_point());
         const int sp_sign = Scalar_Products::reduced_sign(ub_c, x_cp);
         PPL_ASSERT(sp_sign >= 0);
         if (sp_sign == 0) {
           x_gs_condition_3_not_in_y.clear(j);
         }
       }
       for (dimension_type j = y_gs_condition_3_not_in_x.first();
            j != C_Integer<unsigned long>::max;
            j = y_gs_condition_3_not_in_x.next(j)) {
         const Generator& y_cp = y_gs[j];
         PPL_ASSERT(y_cp.is_closure_point());
         const int sp_sign = Scalar_Products::reduced_sign(ub_c, y_cp);
         PPL_ASSERT(sp_sign >= 0);
         if (sp_sign == 0) {
           y_gs_condition_3_not_in_x.clear(j);
         }
       }
     }
   }
 
   if (!(x_gs_condition_3_not_in_y.empty()
         && y_gs_condition_3_not_in_x.empty())) {
     // There exist a closure point satisfying condition 3,
     // hence the hull is not exact.
     return false;
   }
   // The speculative test was not successful:
   // apply the expensive (but conclusive) test for condition 3.
 
   // Consider strict inequalities in `x' violated by `y'.
   for (dimension_type i = x_cs_condition_3.first();
        i != C_Integer<unsigned long>::max; i = x_cs_condition_3.next(i)) {
     const Constraint& x_cs_i = x_cs[i];
     PPL_ASSERT(x_cs_i.is_strict_inequality());
     // Build the equality constraint induced by x_cs_i.
     const Linear_Expression expr(x_cs_i.expression());
     const Constraint eq_i(expr == 0);
     PPL_ASSERT(!(ub.relation_with(eq_i)
                  .implies(Poly_Con_Relation::is_disjoint())));
     Polyhedron ub_inters_hyperplane(ub);
     ub_inters_hyperplane.add_constraint(eq_i);
     Polyhedron y_inters_hyperplane(y);
     y_inters_hyperplane.add_constraint(eq_i);
     if (!y_inters_hyperplane.contains(ub_inters_hyperplane)) {
       // The hull is not exact.
       return false;
     }
   }
 
   // Consider strict inequalities in `y' violated by `x'.
   for (dimension_type i = y_cs_condition_3.first();
        i != C_Integer<unsigned long>::max; i = y_cs_condition_3.next(i)) {
     const Constraint& y_cs_i = y_cs[i];
     PPL_ASSERT(y_cs_i.is_strict_inequality());
     // Build the equality constraint induced by y_cs_i.
     const Constraint eq_i(Linear_Expression(y_cs_i.expression()) == 0);
     PPL_ASSERT(!(ub.relation_with(eq_i)
                  .implies(Poly_Con_Relation::is_disjoint())));
     Polyhedron ub_inters_hyperplane(ub);
     ub_inters_hyperplane.add_constraint(eq_i);
     Polyhedron x_inters_hyperplane(x);
     x_inters_hyperplane.add_constraint(eq_i);
     if (!x_inters_hyperplane.contains(ub_inters_hyperplane)) {
       // The hull is not exact.
       return false;
     }
   }
 
   // The hull is exact.
   m_swap(ub);
   return true;
 }

bool Parma_Polyhedra_Library::Polyhedron::BHZ09_poly_hull_assign_if_exact ( const Polyhedron & y )

protected

Definition at line 1505 of file Polyhedron_nonpublic.cc.

References BHZ09_C_poly_hull_assign_if_exact(), BHZ09_NNC_poly_hull_assign_if_exact(), is_empty(), is_necessarily_closed(), marked_empty(), space_dim, topology(), and upper_bound_assign().

                                                                   {
   Polyhedron& x = *this;
 
   // Private method: the caller must ensure the following.
   PPL_ASSERT(x.topology() == y.topology());
   PPL_ASSERT(x.space_dim == y.space_dim);
 
   // The zero-dim case is trivial.
   if (x.space_dim == 0) {
     x.upper_bound_assign(y);
     return true;
   }
 
   // If `x' or `y' are (known to be) empty, the upper bound is exact.
   if (x.marked_empty()) {
     x = y;
     return true;
   }
   else if (y.is_empty()) {
     return true;
   }
   else if (x.is_empty()) {
     x = y;
     return true;
   }
 
   if (x.is_necessarily_closed()) {
     return x.BHZ09_C_poly_hull_assign_if_exact(y);
   }
   else {
     return x.BHZ09_NNC_poly_hull_assign_if_exact(y);
   }
 }

void Parma_Polyhedra_Library::Polyhedron::bounded_affine_image	(	Variable	var,
		const Linear_Expression &	lb_expr,
		const Linear_Expression &	ub_expr,
		Coefficient_traits::const_reference	denominator = `Coefficient_one()`
	)

Assigns to *this the image of *this with respect to the bounded affine relation $\frac{\mathrm{lb\_expr}}{\mathrm{denominator}} \leq \mathrm{var}' \leq \frac{\mathrm{ub\_expr}}{\mathrm{denominator}}$ .

Parameters

var	The variable updated by the affine relation;
lb_expr	The numerator of the lower bounding affine expression;
ub_expr	The numerator of the upper bounding affine expression;
denominator	The (common) denominator for the lower and upper bounding affine expressions (optional argument with default value 1).

Exceptions

std::invalid_argument Thrown if denominator is zero or if lb_expr (resp., ub_expr) and *this are dimension-incompatible or if var is not a space dimension of *this.

Definition at line 2919 of file Polyhedron_public.cc.

References Parma_Polyhedra_Library::Linear_Expression::coefficient(), Parma_Polyhedra_Library::GREATER_OR_EQUAL, Parma_Polyhedra_Library::LESS_OR_EQUAL, Parma_Polyhedra_Library::Variable::space_dimension(), and Parma_Polyhedra_Library::Linear_Expression::space_dimension().

Referenced by affine_form_image().

                                                                     {
   // The denominator cannot be zero.
   if (denominator == 0) {
     throw_invalid_argument("bounded_affine_image(v, lb, ub, d)", "d == 0");
   }
 
   // Dimension-compatibility checks.
   // `var' should be one of the dimensions of the polyhedron.
   const dimension_type var_space_dim = var.space_dimension();
   if (space_dim < var_space_dim) {
     throw_dimension_incompatible("bounded_affine_image(v, lb, ub, d)",
                                  "v", var);
   }
   // The dimension of `lb_expr' and `ub_expr' should not be
   // greater than the dimension of `*this'.
   const dimension_type lb_space_dim = lb_expr.space_dimension();
   if (space_dim < lb_space_dim) {
     throw_dimension_incompatible("bounded_affine_image(v, lb, ub, d)",
                                  "lb", lb_expr);
   }
   const dimension_type ub_space_dim = ub_expr.space_dimension();
   if (space_dim < ub_space_dim) {
     throw_dimension_incompatible("bounded_affine_image(v, lb, ub, d)",
                                  "ub", ub_expr);
   }
 
   // Any image of an empty polyhedron is empty.
   if (marked_empty()) {
     return;
   }
 
   // Check whether `var' occurs in `lb_expr' and/or `ub_expr'.
   if (lb_expr.coefficient(var) == 0) {
     // Here `var' may only occur in `ub_expr'.
     generalized_affine_image(var,
                              LESS_OR_EQUAL,
                              ub_expr,
                              denominator);
     if (denominator > 0) {
       refine_no_check(lb_expr <= denominator*var);
     }
     else {
       refine_no_check(denominator*var <= lb_expr);
     }
   }
   else if (ub_expr.coefficient(var) == 0) {
     // Here `var' only occurs in `lb_expr'.
     generalized_affine_image(var,
                              GREATER_OR_EQUAL,
                              lb_expr,
                              denominator);
     if (denominator > 0) {
       refine_no_check(denominator*var <= ub_expr);
     }
     else {
       refine_no_check(ub_expr <= denominator*var);
     }
   }
   else {
     // Here `var' occurs in both `lb_expr' and `ub_expr'.
     // To ease the computation, we add an additional dimension.
     const Variable new_var(space_dim);
     add_space_dimensions_and_embed(1);
     // Constrain the new dimension to be equal to `ub_expr'.
     refine_no_check(denominator*new_var == ub_expr);
     // Apply the affine lower bound.
     generalized_affine_image(var,
                              GREATER_OR_EQUAL,
                              lb_expr,
                              denominator);
     if (!marked_empty()) {
       // Now apply the affine upper bound, as recorded in `new_var'.
       refine_no_check(new_var >= var);
     }
     // Remove the temporarily added dimension.
     remove_higher_space_dimensions(space_dim-1);
   }
   PPL_ASSERT_HEAVY(OK());
 }

void Parma_Polyhedra_Library::Polyhedron::bounded_affine_preimage	(	Variable	var,
		const Linear_Expression &	lb_expr,
		const Linear_Expression &	ub_expr,
		Coefficient_traits::const_reference	denominator = `Coefficient_one()`
	)

Assigns to *this the preimage of *this with respect to the bounded affine relation $\frac{\mathrm{lb\_expr}}{\mathrm{denominator}} \leq \mathrm{var}' \leq \frac{\mathrm{ub\_expr}}{\mathrm{denominator}}$ .

Parameters

var	The variable updated by the affine relation;
lb_expr	The numerator of the lower bounding affine expression;
ub_expr	The numerator of the upper bounding affine expression;
denominator	The (common) denominator for the lower and upper bounding affine expressions (optional argument with default value 1).

Exceptions

std::invalid_argument Thrown if denominator is zero or if lb_expr (resp., ub_expr) and *this are dimension-incompatible or if var is not a space dimension of *this.

Definition at line 3004 of file Polyhedron_public.cc.

References Parma_Polyhedra_Library::Linear_Expression::coefficient(), Parma_Polyhedra_Library::Variable::space_dimension(), and Parma_Polyhedra_Library::Linear_Expression::space_dimension().

                                                                        {
   // The denominator cannot be zero.
   if (denominator == 0) {
     throw_invalid_argument("bounded_affine_preimage(v, lb, ub, d)", "d == 0");
   }
 
   // Dimension-compatibility checks.
   // `var' should be one of the dimensions of the polyhedron.
   const dimension_type var_space_dim = var.space_dimension();
   if (space_dim < var_space_dim) {
     throw_dimension_incompatible("bounded_affine_preimage(v, lb, ub, d)",
                                  "v", var);
   }
   // The dimension of `lb_expr' and `ub_expr' should not be
   // greater than the dimension of `*this'.
   const dimension_type lb_space_dim = lb_expr.space_dimension();
   if (space_dim < lb_space_dim) {
     throw_dimension_incompatible("bounded_affine_preimage(v, lb, ub, d)",
                                  "lb", lb_expr);
   }
   const dimension_type ub_space_dim = ub_expr.space_dimension();
   if (space_dim < ub_space_dim) {
     throw_dimension_incompatible("bounded_affine_preimage(v, lb, ub, d)",
                                  "ub", ub_expr);
   }
 
   // Any preimage of an empty polyhedron is empty.
   if (marked_empty()) {
     return;
   }
 
   // Check whether `var' occurs in neither `lb_expr' nor `ub_expr'.
   if (lb_expr.coefficient(var) == 0 && ub_expr.coefficient(var) == 0) {
     if (denominator > 0) {
       refine_no_check(lb_expr <= denominator*var);
       refine_no_check(denominator*var <= ub_expr);
     }
     else {
       refine_no_check(ub_expr <= denominator*var);
       refine_no_check(denominator*var <= lb_expr);
     }
     unconstrain(var);
   }
   else {
     // Here `var' occurs in `lb_expr' or `ub_expr'.
     // To ease the computation, add an additional dimension.
     const Variable new_var(space_dim);
     add_space_dimensions_and_embed(1);
 
     // Swap dimensions `var' and `new_var'.
     if (constraints_are_up_to_date()) {
       con_sys.swap_space_dimensions(var, new_var);
     }
     if (generators_are_up_to_date()) {
       gen_sys.swap_space_dimensions(var, new_var);
     }
 
     // Constrain the new dimension as dictated by `lb_expr' and `ub_expr'.
     // (we force minimization because we will need the generators).
     if (denominator > 0) {
       refine_no_check(lb_expr <= denominator*new_var);
       refine_no_check(denominator*new_var <= ub_expr);
     }
     else {
       refine_no_check(ub_expr <= denominator*new_var);
       refine_no_check(denominator*new_var <= lb_expr);
     }
     // Remove the temporarily added dimension.
     remove_higher_space_dimensions(space_dim-1);
   }
   PPL_ASSERT_HEAVY(OK());
 }

void Parma_Polyhedra_Library::Polyhedron::bounded_BHRZ03_extrapolation_assign	(	const Polyhedron &	y,
		const Constraint_System &	cs,
		unsigned *	tp = `0`
	)

Assigns to *this the result of computing the bounded extrapolation between *this and y using the BHRZ03-widening operator.

Parameters

y	A polyhedron that must be contained in `*this`;
cs	The system of constraints used to improve the widened polyhedron;
tp	An optional pointer to an unsigned variable storing the number of available tokens (to be used when applying the widening with tokens delay technique).

Exceptions

std::invalid_argument Thrown if *this, y and cs are topology-incompatible or dimension-incompatible.

Definition at line 928 of file Polyhedron_widenings.cc.

References Parma_Polyhedra_Library::ANY_COMPLEXITY, Parma_Polyhedra_Library::Box< ITV >::CC76_widening_assign(), and Parma_Polyhedra_Library::Box< ITV >::constraints().

                                                     {
   Rational_Box x_box(*this, ANY_COMPLEXITY);
   const Rational_Box y_box(y, ANY_COMPLEXITY);
   x_box.CC76_widening_assign(y_box);
   limited_BHRZ03_extrapolation_assign(y, cs, tp);
   Constraint_System x_box_cs = x_box.constraints();
   add_recycled_constraints(x_box_cs);
 }

void Parma_Polyhedra_Library::Polyhedron::bounded_H79_extrapolation_assign	(	const Polyhedron &	y,
		const Constraint_System &	cs,
		unsigned *	tp = `0`
	)

Assigns to *this the result of computing the bounded extrapolation between *this and y using the H79-widening operator.

Parameters

y	A polyhedron that must be contained in `*this`;
cs	The system of constraints used to improve the widened polyhedron;
tp	An optional pointer to an unsigned variable storing the number of available tokens (to be used when applying the widening with tokens delay technique).

Exceptions

std::invalid_argument Thrown if *this, y and cs are topology-incompatible or dimension-incompatible.

Definition at line 386 of file Polyhedron_widenings.cc.

References Parma_Polyhedra_Library::ANY_COMPLEXITY, Parma_Polyhedra_Library::Box< ITV >::CC76_widening_assign(), and Parma_Polyhedra_Library::Box< ITV >::constraints().

                                                                 {
   Rational_Box x_box(*this, ANY_COMPLEXITY);
   const Rational_Box y_box(y, ANY_COMPLEXITY);
   x_box.CC76_widening_assign(y_box);
   limited_H79_extrapolation_assign(y, cs, tp);
   Constraint_System x_box_cs = x_box.constraints();
   add_recycled_constraints(x_box_cs);
 }

bool Parma_Polyhedra_Library::Polyhedron::bounds	(	const Linear_Expression &	expr,
		bool	from_above
	)		const

private

Checks if and how expr is bounded in *this.

Returns true if and only if from_above is true and expr is bounded from above in *this, or from_above is false and expr is bounded from below in *this.

Parameters

expr	The linear expression to test;
from_above	`true` if and only if the boundedness of interest is "from above".

Exceptions

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

Definition at line 569 of file Polyhedron_nonpublic.cc.

References Parma_Polyhedra_Library::Scalar_Products::homogeneous_sign(), Parma_Polyhedra_Library::Generator::is_line(), Parma_Polyhedra_Library::Generator::is_line_or_ray(), and Parma_Polyhedra_Library::Linear_Expression::space_dimension().

Referenced by bounds_from_above(), and bounds_from_below().

                                                      {
   // The dimension of `expr' should not be greater than the dimension
   // of `*this'.
   const dimension_type expr_space_dim = expr.space_dimension();
   if (space_dim < expr_space_dim) {
     throw_dimension_incompatible((from_above
                                   ? "bounds_from_above(e)"
                                   : "bounds_from_below(e)"), "e", expr);
   }
 
   // A zero-dimensional or empty polyhedron bounds everything.
   if (space_dim == 0
       || marked_empty()
       || (has_pending_constraints() && !process_pending_constraints())
       || (!generators_are_up_to_date() && !update_generators())) {
     return true;
   }
   // The polyhedron has updated, possibly pending generators.
   for (dimension_type i = gen_sys.num_rows(); i-- > 0; ) {
     const Generator& g = gen_sys[i];
     // Only lines and rays in `*this' can cause `expr' to be unbounded.
     if (g.is_line_or_ray()) {
       const int sp_sign = Scalar_Products::homogeneous_sign(expr, g);
       if (sp_sign != 0
           && (g.is_line()
               || (from_above && sp_sign > 0)
               || (!from_above && sp_sign < 0))) {
         // `*this' does not bound `expr'.
         return false;
       }
     }
   }
   // No sources of unboundedness have been found for `expr'
   // in the given direction.
   return true;
 }

bool Parma_Polyhedra_Library::Polyhedron::bounds_from_above ( const Linear_Expression & expr ) const

inline

Returns true if and only if expr is bounded from above in *this.

Exceptions

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

Definition at line 314 of file Polyhedron_inlines.hh.

References bounds().

                                                                  {
   return bounds(expr, true);
 }

bool Parma_Polyhedra_Library::Polyhedron::bounds_from_below ( const Linear_Expression & expr ) const

inline

Returns true if and only if expr is bounded from below in *this.

Exceptions

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

Definition at line 319 of file Polyhedron_inlines.hh.

References bounds().

                                                                  {
   return bounds(expr, false);
 }

bool Parma_Polyhedra_Library::Polyhedron::can_have_something_pending ( ) const

inlineprivate

Returns true if the polyhedron can have something pending.

Definition at line 180 of file Polyhedron_inlines.hh.

References constraints_are_minimized(), generators_are_minimized(), sat_c_is_up_to_date(), and sat_g_is_up_to_date().

Referenced by intersection_assign(), poly_hull_assign(), and time_elapse_assign().

                                              {
   return constraints_are_minimized()
     && generators_are_minimized()
     && (sat_c_is_up_to_date() || sat_g_is_up_to_date());
 }

bool Parma_Polyhedra_Library::Polyhedron::can_recycle_congruence_systems ( )

inlinestatic

Returns false indicating that this domain cannot recycle congruences.

Definition at line 125 of file Polyhedron_inlines.hh.

                                            {
   return false;
 }

bool Parma_Polyhedra_Library::Polyhedron::can_recycle_constraint_systems ( )

inlinestatic

Returns true indicating that this domain has methods that can recycle constraints.

Definition at line 120 of file Polyhedron_inlines.hh.

                                            {
   return true;
 }

template<typename Input >

Input& Parma_Polyhedra_Library::Polyhedron::check_obj_space_dimension_overflow	(	Input &	input,
		const Topology	topol,
		const char *	method,
		const char *	reason
	)

Definition at line 599 of file Polyhedron_templates.hh.

References check_space_dimension_overflow(), and max_space_dimension().

                                                                    {
   check_space_dimension_overflow(input.space_dimension(),
                                  max_space_dimension(),
                                  topol, method, reason);
   return input;
 }

template<typename Object >

static Object& Parma_Polyhedra_Library::Polyhedron::check_obj_space_dimension_overflow	(	Object &	input,
		Topology	topol,
		const char *	method,
		const char *	reason
	)

staticprotected

PPL::dimension_type Parma_Polyhedra_Library::Polyhedron::check_space_dimension_overflow	(	dimension_type	dim,
		dimension_type	max,
		const Topology	topol,
		const char *	method,
		const char *	reason
	)

staticprotected

Definition at line 2717 of file Polyhedron_nonpublic.cc.

References Parma_Polyhedra_Library::check_space_dimension_overflow(), and Parma_Polyhedra_Library::NECESSARILY_CLOSED.

Referenced by add_space_dimensions_and_embed(), and check_obj_space_dimension_overflow().

                                                                     {
   const char* const domain = (topol == NECESSARILY_CLOSED)
     ? "PPL::C_Polyhedron::" : "PPL::NNC_Polyhedron::";
   return PPL::check_space_dimension_overflow(dim, max, domain, method, reason);
 }

PPL::dimension_type Parma_Polyhedra_Library::Polyhedron::check_space_dimension_overflow	(	dimension_type	dim,
		const Topology	topol,
		const char *	method,
		const char *	reason
	)

staticprotected

Definition at line 2728 of file Polyhedron_nonpublic.cc.

References Parma_Polyhedra_Library::check_space_dimension_overflow(), and max_space_dimension().

                                                                     {
   return check_space_dimension_overflow(dim, Polyhedron::max_space_dimension(),
                                         topol, method, reason);
 }

void Parma_Polyhedra_Library::Polyhedron::clear_constraints_minimized ( )

inlineprivate

Sets status to express that constraints are no longer minimized.

Definition at line 248 of file Polyhedron_inlines.hh.

References Parma_Polyhedra_Library::Polyhedron::Status::reset_c_minimized(), and status.

Referenced by clear_constraints_up_to_date(), intersection_assign(), and remove_pending_to_obtain_constraints().

                                         {
   status.reset_c_minimized();
 }

void Parma_Polyhedra_Library::Polyhedron::clear_constraints_up_to_date ( )

inlineprivate

Sets status to express that constraints are no longer up-to-date.

This also implies that they are neither minimized and both saturation matrices are no longer meaningful.

Definition at line 280 of file Polyhedron_inlines.hh.

References clear_constraints_minimized(), clear_pending_constraints(), clear_sat_c_up_to_date(), clear_sat_g_up_to_date(), Parma_Polyhedra_Library::Polyhedron::Status::reset_c_up_to_date(), and status.

Referenced by poly_hull_assign(), remove_pending_to_obtain_generators(), strongly_minimize_generators(), and time_elapse_assign().

                                          {
   clear_pending_constraints();
   clear_constraints_minimized();
   clear_sat_c_up_to_date();
   clear_sat_g_up_to_date();
   status.reset_c_up_to_date();
   // Can get rid of con_sys here.
 }

void Parma_Polyhedra_Library::Polyhedron::clear_empty ( )

inlineprivate

Clears the status flag indicating that the polyhedron is empty.

Definition at line 243 of file Polyhedron_inlines.hh.

References Parma_Polyhedra_Library::Polyhedron::Status::reset_empty(), and status.

                         {
   status.reset_empty();
 }

void Parma_Polyhedra_Library::Polyhedron::clear_generators_minimized ( )

inlineprivate

Sets status to express that generators are no longer minimized.

Definition at line 253 of file Polyhedron_inlines.hh.

References Parma_Polyhedra_Library::Polyhedron::Status::reset_g_minimized(), and status.

Referenced by clear_generators_up_to_date(), poly_hull_assign(), remove_pending_to_obtain_generators(), and time_elapse_assign().

                                        {
   status.reset_g_minimized();
 }

void Parma_Polyhedra_Library::Polyhedron::clear_generators_up_to_date ( )

inlineprivate

Sets status to express that generators are no longer up-to-date.

This also implies that they are neither minimized and both saturation matrices are no longer meaningful.

Definition at line 290 of file Polyhedron_inlines.hh.

References clear_generators_minimized(), clear_pending_generators(), clear_sat_c_up_to_date(), clear_sat_g_up_to_date(), Parma_Polyhedra_Library::Polyhedron::Status::reset_g_up_to_date(), and status.

Referenced by intersection_assign(), remove_pending_to_obtain_constraints(), and strongly_minimize_constraints().

                                         {
   clear_pending_generators();
   clear_generators_minimized();
   clear_sat_c_up_to_date();
   clear_sat_g_up_to_date();
   status.reset_g_up_to_date();
   // Can get rid of gen_sys here.
 }

void Parma_Polyhedra_Library::Polyhedron::clear_pending_constraints ( )

inlineprivate

Sets status to express that there are no longer pending constraints.

Definition at line 258 of file Polyhedron_inlines.hh.

References Parma_Polyhedra_Library::Polyhedron::Status::reset_c_pending(), and status.

Referenced by clear_constraints_up_to_date(), process_pending_constraints(), and remove_pending_to_obtain_constraints().

                                       {
   status.reset_c_pending();
 }

void Parma_Polyhedra_Library::Polyhedron::clear_pending_generators ( )

inlineprivate

Sets status to express that there are no longer pending generators.

Definition at line 263 of file Polyhedron_inlines.hh.

References Parma_Polyhedra_Library::Polyhedron::Status::reset_g_pending(), and status.

Referenced by clear_generators_up_to_date(), process_pending_generators(), and remove_pending_to_obtain_generators().

                                      {
   status.reset_g_pending();
 }

void Parma_Polyhedra_Library::Polyhedron::clear_sat_c_up_to_date ( )

inlineprivate

Sets status to express that sat_c is no longer up-to-date.

Definition at line 268 of file Polyhedron_inlines.hh.

References Parma_Polyhedra_Library::Polyhedron::Status::reset_sat_c_up_to_date(), and status.

Referenced by clear_constraints_up_to_date(), clear_generators_up_to_date(), obtain_sorted_constraints(), process_pending_generators(), and update_generators().

                                    {
   status.reset_sat_c_up_to_date();
   // Can get rid of sat_c here.
 }

void Parma_Polyhedra_Library::Polyhedron::clear_sat_g_up_to_date ( )

inlineprivate

Sets status to express that sat_g is no longer up-to-date.

Definition at line 274 of file Polyhedron_inlines.hh.

References Parma_Polyhedra_Library::Polyhedron::Status::reset_sat_g_up_to_date(), and status.

Referenced by clear_constraints_up_to_date(), clear_generators_up_to_date(), obtain_sorted_generators(), process_pending_constraints(), and update_constraints().

                                    {
   status.reset_sat_g_up_to_date();
   // Can get rid of sat_g here.
 }

void Parma_Polyhedra_Library::Polyhedron::concatenate_assign ( const Polyhedron & y )

Assigns to *this the concatenation of *this and y, taken in this order.

Exceptions

std::invalid_argument	Thrown if `*this` and `y` are topology-incompatible.
std::length_error	Thrown if the concatenation would cause the vector space to exceed dimension `max_space_dimension()`.

Definition at line 184 of file Polyhedron_chdims.cc.

References Parma_Polyhedra_Library::check_space_dimension_overflow(), Parma_Polyhedra_Library::Constraint_System::clear(), constraints(), marked_empty(), Parma_Polyhedra_Library::max_space_dimension(), Parma_Polyhedra_Library::Constraint_System::num_rows(), space_dim, Parma_Polyhedra_Library::swap(), Parma_Polyhedra_Library::Constraint_System::sys, and topology().

                                                      {
   if (topology() != y.topology()) {
     throw_topology_incompatible("concatenate_assign(y)", "y", y);
   }
 
   // The space dimension of the resulting polyhedron should not
   // overflow the maximum allowed space dimension.
   const dimension_type added_columns = y.space_dim;
   check_space_dimension_overflow(added_columns,
                                  max_space_dimension() - space_dimension(),
                                  topology(),
                                  "concatenate_assign(y)",
                                  "concatenation exceeds the maximum "
                                  "allowed space dimension");
 
   // If `*this' or `y' are empty polyhedra, it is sufficient to adjust
   // the dimension of the space.
   if (marked_empty() || y.marked_empty()) {
     space_dim += added_columns;
     set_empty();
     return;
   }
 
   // If `y' is a non-empty 0-dim space polyhedron, the result is `*this'.
   if (added_columns == 0) {
     return;
   }
 
   // If `*this' is a non-empty 0-dim space polyhedron, the result is `y'.
   if (space_dim == 0) {
     *this = y;
     return;
   }
 
   // TODO: this implementation is just an executable specification.
   Constraint_System cs = y.constraints();
 
   // The constraints of `x' (possibly with pending rows) are required.
   if (has_pending_generators()) {
     process_pending_generators();
   }
   else if (!constraints_are_up_to_date()) {
     update_constraints();
   }
 
   // The matrix for the new system of constraints is obtained
   // by leaving the old system of constraints in the upper left-hand side
   // and placing the constraints of `cs' in the lower right-hand side.
   // NOTE: here topologies agree, whereas dimensions may not agree.
   const dimension_type added_rows = cs.num_rows();
 
   // We already dealt with the cases of an empty or zero-dim `y' polyhedron;
   // also, `cs' contains the low-level constraints, at least.
   PPL_ASSERT(added_rows > 0 && added_columns > 0);
 
   con_sys.set_space_dimension(con_sys.space_dimension() + added_columns);
 
   if (can_have_something_pending()) {
     // Steal the constraints from `cs' and put them in `con_sys'
     // using the right displacement for coefficients.
     for (dimension_type i = 0; i < added_rows; ++i) {
       cs.sys.rows[i].shift_space_dimensions(Variable(0), space_dim);
       con_sys.insert_pending(cs.sys.rows[i], Recycle_Input());
     }
     cs.clear();
 
     // If `*this' can support pending constraints, then, since we have
     // resized the system of constraints, we must also add to the generator
     // system those lines corresponding to the newly added dimensions,
     // because the non-pending parts of `con_sys' and `gen_sys' must still
     // be a DD pair in minimal form.
     gen_sys.add_universe_rows_and_space_dimensions(added_columns);
     // Since we added new lines at the beginning of `x.gen_sys',
     // we also have to adjust the saturation matrix `sat_c'.
     // FIXME: if `sat_c' is not up-to-date, could not we directly update
     // `sat_g' by resizing it and shifting its columns?
     if (!sat_c_is_up_to_date()) {
       sat_c.transpose_assign(sat_g);
       set_sat_c_up_to_date();
     }
     clear_sat_g_up_to_date();
     sat_c.resize(sat_c.num_rows() + added_columns, sat_c.num_columns());
     // The old saturation rows are copied at the end of the matrix.
     // The newly introduced lines saturate all the non-pending constraints,
     // thus their saturation rows are made of zeroes.
     using std::swap;
     for (dimension_type i = sat_c.num_rows() - added_columns;
       i-- > 0; ) {
       swap(sat_c[i], sat_c[i+added_columns]);
     }
     // Since `added_rows > 0', we now have pending constraints.
     set_constraints_pending();
   }
   else {
     // Steal the constraints from `cs' and put them in `con_sys'
     // using the right displacement for coefficients.
     for (dimension_type i = 0; i < added_rows; ++i) {
       cs.sys.rows[i].shift_space_dimensions(Variable(0), space_dim);
       con_sys.insert(cs.sys.rows[i], Recycle_Input());
     }
 #if !BE_LAZY
     con_sys.sort_rows();
 #endif
     clear_constraints_minimized();
     clear_generators_up_to_date();
     clear_sat_g_up_to_date();
     clear_sat_c_up_to_date();
   }
   // Update space dimension.
   space_dim += added_columns;
 
   // The system of constraints may be unsatisfiable,
   // thus we do not check for satisfiability.
   PPL_ASSERT_HEAVY(OK());
 }

Congruence_System Parma_Polyhedra_Library::Polyhedron::congruences ( ) const

inline

Returns a system of (equality) congruences satisfied by *this.

Definition at line 367 of file Polyhedron_inlines.hh.

References minimized_constraints().

                               {
   return Congruence_System(minimized_constraints());
 }

bool Parma_Polyhedra_Library::Polyhedron::constrains ( Variable var ) const

Returns true if and only if var is constrained in *this.

Exceptions

std::invalid_argument Thrown if var is not a space dimension of *this.

Definition at line 729 of file Polyhedron_public.cc.

References Parma_Polyhedra_Library::Expression_Hide_Last< T >::all_zeroes(), Parma_Polyhedra_Library::Generator::coefficient(), Parma_Polyhedra_Library::Generator::expression(), Parma_Polyhedra_Library::Variable::id(), Parma_Polyhedra_Library::Generator::is_line(), Parma_Polyhedra_Library::Generator::is_line_or_ray(), Parma_Polyhedra_Library::Boundary_NS::sgn(), and Parma_Polyhedra_Library::Variable::space_dimension().

                                                   {
   // `var' should be one of the dimensions of the polyhedron.
   const dimension_type var_space_dim = var.space_dimension();
   if (space_dim < var_space_dim) {
     throw_dimension_incompatible("constrains(v)", "v", var);
   }
 
   // An empty polyhedron constrains all variables.
   if (marked_empty()) {
     return true;
   }
 
   if (generators_are_up_to_date() && !has_pending_constraints()) {
     // Since generators are up-to-date and there are no pending
     // constraints, the generator system (since it is well formed)
     // contains a point.  Hence the polyhedron is not empty.
     if (constraints_are_up_to_date() && !has_pending_generators()) {
       // Here a variable is constrained if and only if it is
       // syntactically constrained.
       goto syntactic_check;
     }
     if (generators_are_minimized()) {
       // Try a quick, incomplete check for the universe polyhedron:
       // a universe polyhedron constrains no variable.
       // Count the number of non-pending
       // (hence, linearly independent) lines.
       dimension_type num_lines = 0;
       const dimension_type first_pending = gen_sys.first_pending_row();
       for (dimension_type i = first_pending; i-- > 0; ) {
         if (gen_sys[i].is_line()) {
           ++num_lines;
         }
       }
 
       if (num_lines == space_dim) {
         return false;
       }
     }
 
     // Scan generators: perhaps we will find a generator equivalent to
     // line(var) or a pair of generators equivalent to ray(-var) and
     // ray(var).
     bool have_positive_ray = false;
     bool have_negative_ray = false;
     const dimension_type var_id = var.id();
     for (dimension_type i = gen_sys.num_rows(); i-- > 0; ) {
       const Generator& gen_sys_i = gen_sys[i];
       if (gen_sys_i.is_line_or_ray()) {
         const int sign = sgn(gen_sys_i.coefficient(var));
         if (sign != 0) {
           if (gen_sys_i.expression().all_zeroes(1, var_id)
               && gen_sys_i.expression().all_zeroes(var_id + 1, space_dim + 1)) {
 
             if (gen_sys_i.is_line()) {
               return true;
             }
             if (sign > 0) {
               if (have_negative_ray) {
                 return true;
               }
               else {
                 have_positive_ray = true;
               }
             }
             else if (have_positive_ray) {
               return true;
             }
             else {
               have_negative_ray = true;
             }
           }
         }
       }
     }
 
     // We are still here: at least we know that, since generators are
     // up-to-date and there are no pending constraints, then the
     // generator system (since it is well formed) contains a point.
     // Hence the polyhedron is not empty.
     if (has_pending_generators()) {
       process_pending_generators();
     }
     else if (!constraints_are_up_to_date()) {
       update_constraints();
     }
     goto syntactic_check;
   }
 
   // We must minimize to detect emptiness and obtain constraints.
   if (!minimize()) {
     return true;
   }
 
  syntactic_check:
   for (dimension_type i = con_sys.num_rows(); i-- > 0; ) {
     if (con_sys[i].coefficient(var) != 0) {
       return true;
     }
   }
   return false;
 }

const PPL::Constraint_System & Parma_Polyhedra_Library::Polyhedron::constraints ( ) const

Returns the system of constraints.

Definition at line 78 of file Polyhedron_public.cc.

References Parma_Polyhedra_Library::Constraint_System::adjust_topology_and_space_dimension(), Parma_Polyhedra_Library::swap(), and Parma_Polyhedra_Library::Constraint_System::zero_dim_empty().

Referenced by Parma_Polyhedra_Library::BD_Shape< T >::BD_Shape(), BHZ09_NNC_poly_hull_assign_if_exact(), Parma_Polyhedra_Library::Box< ITV >::Box(), Parma_Polyhedra_Library::C_Polyhedron::C_Polyhedron(), concatenate_assign(), Parma_Polyhedra_Library::Grid::Grid(), Parma_Polyhedra_Library::NNC_Polyhedron::NNC_Polyhedron(), Parma_Polyhedra_Library::Octagonal_Shape< T >::Octagonal_Shape(), and poly_difference_assign().

                                  {
   if (marked_empty()) {
     // We want `con_sys' to only contain the unsatisfiable constraint
     // of the appropriate dimension.
     if (con_sys.has_no_rows()) {
       // The 0-dim unsatisfiable constraint is extended to
       // the appropriate dimension and then stored in `con_sys'.
       Constraint_System unsat_cs = Constraint_System::zero_dim_empty();
       unsat_cs.adjust_topology_and_space_dimension(topology(), space_dim);
       swap(const_cast<Constraint_System&>(con_sys), unsat_cs);
     }
     else {
       // Checking that `con_sys' contains the right thing.
       PPL_ASSERT(con_sys.space_dimension() == space_dim);
       PPL_ASSERT(con_sys.num_rows() == 1);
       PPL_ASSERT(con_sys[0].is_inconsistent());
     }
     return con_sys;
   }
 
   if (space_dim == 0) {
     // Zero-dimensional universe.
     PPL_ASSERT(con_sys.num_rows() == 0 && con_sys.space_dimension() == 0);
     return con_sys;
   }
 
   // If the polyhedron has pending generators, we process them to obtain
   // the constraints. No processing is needed if the polyhedron has
   // pending constraints.
   if (has_pending_generators()) {
     process_pending_generators();
   }
   else if (!constraints_are_up_to_date()) {
     update_constraints();
   }
 
   // TODO: reconsider whether to really sort constraints at this stage.
 #if ENSURE_SORTEDNESS
   // We insist in returning a sorted system of constraints,
   // but sorting is useless if there are pending constraints.
   if (!has_pending_constraints())
     obtain_sorted_constraints();
 #endif
   return con_sys;
 }

bool Parma_Polyhedra_Library::Polyhedron::constraints_are_minimized ( ) const

inlineprivate

Returns true if the system of constraints is minimized.

Note that only weak minimization is entailed, so that an NNC polyhedron may still have $\epsilon$ -redundant constraints.

Definition at line 145 of file Polyhedron_inlines.hh.

References status, and Parma_Polyhedra_Library::Polyhedron::Status::test_c_minimized().

Referenced by Parma_Polyhedra_Library::BD_Shape< T >::BD_Shape(), BHRZ03_combining_constraints(), BHRZ03_evolving_points(), BHRZ03_evolving_rays(), can_have_something_pending(), Parma_Polyhedra_Library::Grid::Grid(), is_included_in(), Parma_Polyhedra_Library::Octagonal_Shape< T >::Octagonal_Shape(), quick_equivalence_test(), select_CH78_constraints(), select_H79_constraints(), simplified_constraints(), and simplify_using_context_assign().

                                             {
   return status.test_c_minimized();
 }

bool Parma_Polyhedra_Library::Polyhedron::constraints_are_up_to_date ( ) const

inlineprivate

Returns true if the system of constraints is up-to-date.

Definition at line 135 of file Polyhedron_inlines.hh.

References status, and Parma_Polyhedra_Library::Polyhedron::Status::test_c_up_to_date().

Referenced by add_space_dimensions_and_embed(), Parma_Polyhedra_Library::BD_Shape< T >::BD_Shape(), Parma_Polyhedra_Library::Box< ITV >::Box(), Parma_Polyhedra_Library::Grid::Grid(), H79_widening_assign(), intersection_assign(), is_included_in(), map_space_dimensions(), Parma_Polyhedra_Library::Octagonal_Shape< T >::Octagonal_Shape(), operator=(), Polyhedron(), simplified_constraints(), and simplify_using_context_assign().

                                              {
   return status.test_c_up_to_date();
 }

bool Parma_Polyhedra_Library::Polyhedron::contains ( const Polyhedron & y ) const

Returns true if and only if *this contains y.

Exceptions

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

Definition at line 3927 of file Polyhedron_public.cc.

References is_empty(), is_included_in(), marked_empty(), quick_equivalence_test(), space_dim, topology(), and TVB_TRUE.

Referenced by BHRZ03_combining_constraints(), BHRZ03_evolving_points(), BHRZ03_evolving_rays(), BHRZ03_widening_assign(), BHZ09_NNC_poly_hull_assign_if_exact(), Parma_Polyhedra_Library::Pointset_Powerset< PSET >::check_containment(), H79_widening_assign(), poly_difference_assign(), poly_hull_assign_if_exact(), and strictly_contains().

                                                  {
   const Polyhedron& x = *this;
 
   // Topology compatibility check.
   if (x.topology() != y.topology()) {
     throw_topology_incompatible("contains(y)", "y", y);
   }
 
   // Dimension-compatibility check.
   if (x.space_dim != y.space_dim) {
     throw_dimension_incompatible("contains(y)", "y", y);
   }
 
   if (y.marked_empty()) {
     return true;
   }
   else if (x.marked_empty()) {
     return y.is_empty();
   }
   else if (y.space_dim == 0) {
     return true;
   }
   else if (x.quick_equivalence_test(y) == Polyhedron::TVB_TRUE) {
     return true;
   }
   else {
     return y.is_included_in(x);
   }
 }

bool Parma_Polyhedra_Library::Polyhedron::contains_integer_point ( ) const

Returns true if and only if *this contains at least one integer point.

Definition at line 598 of file Polyhedron_public.cc.

                                             {
   // Any empty polyhedron does not contain integer points.
   if (marked_empty()) {
     return false;
   }
   // A zero-dimensional, universe polyhedron has, by convention, an
   // integer point.
   if (space_dim == 0) {
     return true;
   }
 
   // CHECKME: do we really want to call conversion to check for emptiness?
   if (has_pending_constraints() && !process_pending()) {
     // Empty again.
     return false;
   }
 
   // FIXME: do also exploit info regarding rays and lines, if possible.
   // Is any integer point already available?
   PPL_ASSERT(!has_pending_constraints());
   if (generators_are_up_to_date()) {
     for (dimension_type i = gen_sys.num_rows(); i-- > 0; ) {
       if (gen_sys[i].is_point() && gen_sys[i].divisor() == 1) {
         return true;
       }
     }
   }
   const Constraint_System& cs = constraints();
 #if 0 // TEMPORARILY DISABLED.
   MIP_Problem mip(space_dim,
                   cs.begin(), cs.end(),
                   Variables_Set(Variable(0), Variable(space_dim-1)));
 #else
   // FIXME: temporary workaround, to be removed as soon as the MIP
   // problem class will correctly and precisely handle
   // ((strict) in-) equality constraints having all integer variables.
   MIP_Problem mip(space_dim);
   mip.add_to_integer_space_dimensions(Variables_Set(Variable(0),
                                                     Variable(space_dim-1)));
   PPL_DIRTY_TEMP_COEFFICIENT(homogeneous_gcd);
   PPL_DIRTY_TEMP_COEFFICIENT(gcd);
   PPL_DIRTY_TEMP(mpq_class, rational_inhomogeneous);
   PPL_DIRTY_TEMP_COEFFICIENT(tightened_inhomogeneous);
   for (Constraint_System::const_iterator cs_i = cs.begin(),
          cs_end = cs.end(); cs_i != cs_end; ++cs_i) {
     const Constraint& c = *cs_i;
     const Constraint::Type c_type = c.type();
     const Coefficient& inhomogeneous = c.inhomogeneous_term();
     if (c_type == Constraint::STRICT_INEQUALITY) {
       // CHECKME: should we change the behavior of Linear_Expression(c) ?
       // Compute the GCD of the coefficients of c
       // (disregarding the inhomogeneous term and the epsilon dimension).
       homogeneous_gcd = c.expression().gcd(1, space_dim + 1);
       if (homogeneous_gcd == 0) {
         // NOTE: since tautological constraints are already filtered away
         // by iterators, here we must have an inconsistent constraint.
         PPL_ASSERT(c.is_inconsistent());
         return false;
       }
       Linear_Expression le(c.expression());
       if (homogeneous_gcd != 1) {
         le /= homogeneous_gcd;
       }
       // Further tighten the constraint if the inhomogeneous term
       // was integer, i.e., if `homogeneous_gcd' divides `inhomogeneous'.
       gcd_assign(gcd, homogeneous_gcd, inhomogeneous);
       if (gcd == homogeneous_gcd) {
         le -= 1;
       }
       mip.add_constraint(le >= 0);
     }
     else {
       // Equality or non-strict inequality.
       // If possible, avoid useless gcd computations.
       if (inhomogeneous == 0) {
         // The inhomogeneous term cannot be tightened.
         mip.add_constraint(c);
       }
       else {
         // Compute the GCD of the coefficients of c
         // (disregarding the inhomogeneous term)
         // to see whether or not the inhomogeneous term can be tightened.
         homogeneous_gcd = c.expression().gcd(1, space_dim + 1);
         if (homogeneous_gcd == 0) {
           // NOTE: since tautological constraints are already filtered away
           // by iterators, here we must have an inconsistent constraint.
           PPL_ASSERT(c.is_inconsistent());
           return false;
         }
         else if (homogeneous_gcd == 1) {
           // The normalized inhomogeneous term is integer:
           // add the constraint as-is.
           mip.add_constraint(c);
         }
         else {
           PPL_ASSERT(homogeneous_gcd > 1);
           // Here the normalized inhomogeneous term is rational:
           // the constraint has to be tightened.
 #ifndef NDEBUG
           // `homogeneous_gcd' does not divide `inhomogeneous'.
           // FIXME: add a divisibility test for Coefficient.
           gcd_assign(gcd, homogeneous_gcd, inhomogeneous);
           PPL_ASSERT(gcd == 1);
 #endif
           if (c.type() == Constraint::EQUALITY) {
             return false;
           }
           // Extract the homogeneous part of the constraint.
           Linear_Expression le(c.expression());
           le -= inhomogeneous;
           // Tighten the inhomogeneous term.
           assign_r(rational_inhomogeneous.get_num(),
                    inhomogeneous, ROUND_NOT_NEEDED);
           assign_r(rational_inhomogeneous.get_den(),
                    homogeneous_gcd, ROUND_NOT_NEEDED);
           // Note: canonicalization is not needed (as gcd == 1).
           PPL_ASSERT(is_canonical(rational_inhomogeneous));
           assign_r(tightened_inhomogeneous,
                    rational_inhomogeneous, ROUND_DOWN);
           tightened_inhomogeneous *= homogeneous_gcd;
           le += tightened_inhomogeneous;
           mip.add_constraint(le >= 0);
         }
       }
     }
   }
 #endif // TEMPORARY WORKAROUND.
   return mip.is_satisfiable();
 }

template<typename Source_Linear_System , typename Dest_Linear_System >

dimension_type Parma_Polyhedra_Library::Polyhedron::conversion	(	Source_Linear_System &	source,
		dimension_type	start,
		Dest_Linear_System &	dest,
		Bit_Matrix &	sat,
		dimension_type	num_lines_or_equalities
	)

staticprivate

Performs the conversion from constraints to generators and vice versa.

Returns: The number of lines of the polyhedron or the number of equality constraints in the result of conversion.

Parameters

source	The system to use to convert `dest:` it may be modified;
start	The index of `source` row from which conversion begin;
dest	The result of the conversion;
sat	The saturation matrix telling us, for each row in `source`, which are the rows of `dest` that satisfy but do not saturate it;
num_lines_or_equalities	The number of rows in the system `dest` that are either lines of the polyhedron (when `dest` is a system of generators) or equality constraints (when `dest` is a system of constraints).

For simplicity, all the following comments assume we are converting a constraint system source to a generator system dest; the comments for the symmetric case can be obtained by duality.

If some of the constraints in source are redundant, they will be removed. This is why the source is not declared to be a constant parameter.

If start is 0, then source is a sorted system; also, dest is a generator system corresponding to an empty constraint system. If otherwise start is greater than 0, then the two sub-systems of source made by the non-pending rows and the pending rows, respectively, are both sorted; also, dest is the generator system corresponding to the non-pending constraints of source.

Independently from the value of start, dest has lines from index 0 to index num_lines_or_equalities - 1 and rays/points from index num_lines_or_equalities to the last of its rows.

Note that here the rows of sat are indexed by rows of dest and its columns are indexed by rows of source.

We know that polyhedra can be represented by both a system of constraints or a system of generators (points, rays and lines) (see Section Representations of Convex Polyhedra). When we have both descriptions for a polyhedron $P$ we have what is called a double description (or DD pair) for $P$ .

Here, the representation system refers to the system $C$ whose rows represent the constraints that characterize $P$ and the generating system, the system $G$ whose rows represent the generators of $P$ . We say that a pair $(C, G)$ of (real) systems is a double description pair if

$C\vect{x} \geq \vect{0} \quad\iff\quad \exists \vect{\lambda} \geq \vect{0} \mathrel{.} \vect{x} = G\vect{\lambda}.$

The term "double description" is quite natural in the sense that such a pair contains two different description of the same object. In fact, if we refer to the cone representation of a polyhedron $P$ and we call $C$ and $G$ the systems of constraints and rays respectively, we have

$P = \{\, \vect{x} \in \Rset^n \mid C\vect{x} \geq \vect{0}\, \} = \{\, \vect{x} \in \Rset^n \mid \vect{x} = G\vect{\lambda} \text{ for some } \vect{\lambda} \geq \vect{0}\, \}.$

Because of the theorem of Minkowski (see Section Further Notation and Terminology), we can say that, given a $m \times n$ representation system $C$ such that $\mathop{\mathrm{rank}}(C) = n = \mathit{dimension of the whole space}$ for a non-empty polyhedron $P$ , it is always possible to find a generating system $G$ for $P$ such that $(C, G)$ is a DD pair. Conversely, Weyl's theorem ensures that, for each generating system $G$ , it is possible to find a representation system $C$ such that is a DD pair.

For efficiency reasons, our representation of polyhedra makes use of a double description. We are thus left with two problems:

given find such that is a DD pair;
given find such that is a DD pair.

Using Farkas' Lemma we can prove that these two problems are computationally equivalent (i.e., linear-time reducible to each other). Farkas' Lemma establishes a fundamental property of vectors in $\Rset^n$ that, in a sense, captures the essence of duality. Consider a matrix $A \in \Rset^{m \times n}$ and let $\{ \vect{a}_1, \ldots, \vect{a}_m \}$ be its set of row vectors. Consider also another vector $\vect{c} \in \Rset^n$ such that, whenever a vector $\vect{y} \in \Rset^n$ has a non-negative projection on the $\vect{a}_i$ 's, it also has a non-negative projection on $\vect{c}$ . The lemma states that $\vect{c}$ has this property if and only if it is in the cone generated by the $\vect{a}_i$ 's. Formally, the lemma states the equivalence of the two following assertions:

$\forall \vect{y} \mathrel{:} (A\vect{y} \geq 0 \implies \langle \vect{y},\vect{c} \rangle \geq 0)$ ;
$\exists \vect{\lambda} \geq \vect{0} \mathrel{.} \vect{c}^\mathrm{T} = \vect{\lambda}^\mathrm{T}A$ .

With this result we can prove that $(C, G)$ is a DD pair if and only if $(G^\mathrm{T}, C^\mathrm{T})$ is a DD pair.

Suppose $(C, G)$ is a DD pair. Thus, for each $x$ of the appropriate dimension, $C\vect{x} \geq \vect{0}$ if and only if $\exists \lambda \geq 0 \mathrel{.} \vect{x} = G\vect{\lambda}$ , which is of course equivalent to $\exists \vect{\lambda} \geq \vect{0} \mathrel{.} \vect{x}^\mathrm{T} = \vect{\lambda}^\mathrm{T}G^\mathrm{T}$ .

First, we assume that $\vect{z}$ is such that $G^\mathrm{T}\vect{z} \geq \vect{0}$ and we will show that $\exists \vect{\mu} \geq \vect{0} \mathrel{.} \vect{z} = C^\mathrm{T}\vect{\mu}$ . Let $\vect{x}$ be such that $C\vect{x} \geq \vect{0}$ . Since $(C, G)$ is a DD pair, this is equivalent to $\exists \vect{\lambda} \geq \vect{0} \mathrel{.} \vect{x}^\mathrm{T} = \vect{\lambda}^\mathrm{T}G^\mathrm{T}$ , which, by Farkas' Lemma is equivalent to $\forall \vect{y} \mathrel{:} (G^\mathrm{T}\vect{y} \geq \vect{0} \implies \langle \vect{y}, \vect{x} \rangle \geq 0)$ . Taking $\vect{y} = \vect{z}$ and recalling our assumption that $G^\mathrm{T}\vect{z} \geq \vect{0}$ we can conclude that $\langle \vect{z}, \vect{x} \rangle \geq 0$ , that is equivalent to $\langle \vect{x}, \vect{z} \rangle \geq 0$ . We have thus established that $\forall \vect{x} \mathrel{:} (C\vect{x} \geq \vect{0} \implies \langle \vect{x}, \vect{z} \rangle \geq 0)$ . By Farkas' Lemma, this is equivalent to $\exists \vect{\mu} \geq \vect{0} \mathrel{.} \vect{z}^\mathrm{T} = \vect{\mu}^\mathrm{T} C$ , which is equivalent to what we wanted to prove, that is, $\exists \vect{\mu} \geq \vect{0} \mathrel{.} \vect{z} = C^\mathrm{T}\vect{\mu}$ .

In order to prove the reverse implication, the following observation turns out to be useful: when $(C, G)$ is a DD pair, $CG \geq 0$ . In fact, let $\vect{e}_j$ be the vector whose components are all $0$ apart from the $j$ -th one, which is $1$ . Clearly $\vect{e}_j \geq \vect{0}$ and, taking $\vect{\lambda} = \vect{e}_j$ and $\vect{x} = G\vect{\lambda} = G \vect{e}_j$ , we have $C\vect{x} = C(G \vect{e}_j) = (CG)\vect{e}_j \geq \vect{0}$ , since $(C, G)$ is a DD pair. Thus, as $(CG)\vect{e}_j$ is the $j$ -th column of $CG$ and since the choice of $j$ was arbitrary, $CG \geq \vect{0}$ .

We now assume that $\vect{z}$ is such that $\exists \vect{\mu} \geq \vect{0} \mathrel{.} \vect{z} = C^\mathrm{T}\vect{\mu}$ and we will prove that $G^\mathrm{T}\vect{z} \geq \vect{0}$ . By Farkas' Lemma, the assumption $\exists \vect{\mu} \geq \vect{0} \mathrel{.} \vect{z}^\mathrm{T} = \vect{\mu}^\mathrm{T}C$ , is equivalent to $\forall \vect{y} \mathrel{:} (C\vect{y} \geq \vect{0} \implies \langle \vect{y}, \vect{z} \rangle \geq 0)$ . If we take $\vect{y} = G\vect{e}_j$ then $C\vect{y} = CG\vect{e}_j \geq 0$ , since $CG \geq \vect{0}$ . So $\langle \vect{y}, \vect{z} \rangle = (\vect{e}_j^\mathrm{T}G^\mathrm{T}) \vect{z} = \vect{e}_j^\mathrm{T}(G^\mathrm{T} \vect{z}) \geq 0$ , that is, the $j$ -th component of $G^\mathrm{T}\vect{z}$ is non-negative. The arbitrary choice of $j$ allows us to conclude that $G^\mathrm{T}\vect{z} \geq \vect{0}$ , as required.

In view of this result, the following exposition assumes, for clarity, that the conversion being performed is from constraints to generators. Thus, even if the roles of source and dest can be interchanged, in the sequel we assume the source system will contain the constraints that represent the polyhedron and the dest system will contain the generator that generates it.

There are some observations that are useful to understand this function:

Observation 1: Let $A$ be a system of constraints that generate the polyhedron $P$ and $\vect{c}$ a new constraint that must be added. Suppose that there is a line $\vect{z}$ that does not saturate the constraint $\vect{c}$ . If we combine the old lines and rays that do not saturate $\vect{c}$ (except $\vect{z}$ ) with $\vect{z}$ such that the new ones saturate $\vect{c}$ , the new lines and rays also saturate the constraints saturated by the old lines and rays.

In fact, if $\vect{y}_1$ is the old generator that does not saturate $\vect{c}$ , $\vect{y}_2$ is the new one such that

$\vect{y}_2 = \lambda \vect{y}_1 + \mu \vect{z}$

and $\vect{c}_1$ is a previous constraint that $\vect{y}_1$ and $\vect{z}$ saturates, we can see

$\langle \vect{c}_1, \vect{y}_2 \rangle = \langle \vect{c}_1, (\lambda \vect{y}_1 + \mu \vect{z}) \rangle = \lambda \langle \vect{c}_1, \vect{y}_1 \rangle + \mu \langle \vect{c}_1, \vect{z} \rangle = 0 + \mu \langle \vect{c}_1, \vect{z} \rangle = \mu \langle \vect{c}_1, \vect{z} \rangle$

and

$\mu \langle \vect{c}_1, \vect{z} \rangle = 0.$

Proposition 1: Let $\vect{r}_1$ and $\vect{r}_2$ be distinct rays of $P$ . Then the following statements are equivalent: a) $\vect{r}_1$ and $\vect{r}_2$ are adjacent extreme rays (see Section Further Notation and Terminology); b) $\vect{r}_1$ and $\vect{r}_2$ are extreme rays and the rank of the system composed by the constraints saturated by both $\vect{r}_1$ and $\vect{r}_2$ is equal to $d - 2$ , where $d$ is the rank of the system of constraints.

In fact, let $F$ be the system of generators that saturate the constraints saturated by both $\vect{r}_1$ and $\vect{r}_2$ . If b) holds, the set $F$ is 2-dimensional and $\vect{r}_1$ and $\vect{r}_2$ generate this set. So, every generator $\vect{x}$ of $F$ can be built as a combination of $\vect{r}_1$ and $\vect{r}_2$ , i.e.

$\vect{x} = \lambda \vect{r}_1 + \mu \vect{r}_2.$

This combination is non-negative because there exists at least a constraint $c$ saturated by $\vect{r}_1$ and not $\vect{r}_2$ (or vice versa) (because they are distinct) for which

$\langle \vect{c}, \vect{x} \rangle \geq 0$

and

$\langle \vect{c}, \vect{x} \rangle = \lambda \langle \vect{c}, \vect{r}_1 \rangle (or = \mu \langle \vect{c}, \vect{r}_2 \rangle).$

So, there is no other extreme ray in $F$ and a) holds. Otherwise, if b) does not hold, the rank of the system generated by the constraints saturated by both $\vect{r}_1$ and $\vect{r}_2$ is equal to $d - k$ , with k >= 3, the set $F$ is k -dimensional and at least k extreme rays are necessary to generate $F$ . So, $\vect{r}_1$ and $\vect{r}_2$ are not adjacent and a) does not hold.

Proposition 2: When we build the new system of generators starting from a system $A$ of constraints of $P$ , if $\vect{c}$ is the constraint to add to $A$ and all lines of $P$ saturate $\vect{c}$ , the new set of rays is the union of those rays that saturate, of those that satisfy and of a set $\overline Q$ of rays such that each of them

lies on the hyper-plane represented by the k-th constraint,
is a positive combination of two adjacent rays $\vect{r}_1$ and $\vect{r}_2$ such that the first one satisfies the constraint and the other does not satisfy it. If the adjacency property is not taken in account, the new set of rays is not irredundant, in general.

In fact, if $\vect{r}_1$ and $\vect{r}_2$ are not adjacent, the rank of the system composed by the constraints saturated by both $\vect{r}_1$ and $\vect{r}_2$ is different from $d - 2$ (see the previous proposition) or neither $\vect{r}_1$ nor $\vect{r}_2$ are extreme rays. Since the new ray $\vect{r}$ is a combination of $\vect{r}_1$ and $\vect{r}_2$ , it saturates the same constraints saturated by both $\vect{r}_1$ and $\vect{r}_2$ . If the rank is less than $d - 2$ , the rank of the system composed by $\vect{c}$ (that is saturated by $\vect{r}$ ) and by the constraints of $A$ saturated by $\vect{r}$ is less than $d - 1$ . It means that $r$ is redundant (see Section Further Notation and Terminology). If neither $\vect{r}_1$ nor $\vect{r}_2$ are extreme rays, they belong to a 2-dimensional face containing exactly two extreme rays of $P$ . These two adjacent rays build a ray equal to $\vect{r}$ and so $\vect{r}$ is redundant.

Definition at line 369 of file Polyhedron_conversion_templates.hh.

Referenced by add_and_minimize(), and minimize().

                                                                {
   typedef typename Dest_Linear_System::row_type dest_row_type;
   typedef typename Source_Linear_System::row_type source_row_type;
 
   // Constraints and generators must have the same dimension,
   // otherwise the scalar products below will bomb.
   PPL_ASSERT(source.space_dimension() == dest.space_dimension());
   const dimension_type source_space_dim = source.space_dimension();
   const dimension_type source_num_rows = source.num_rows();
   const dimension_type source_num_columns = source_space_dim
     + (source.is_necessarily_closed() ? 1U : 2U);
 
 
   dimension_type dest_num_rows = dest.num_rows();
   // The rows removed from `dest' will be placed in this vector, so they
   // can be recycled if needed.
   std::vector<dest_row_type> recyclable_dest_rows;
 
   using std::swap;
 
   // By construction, the number of columns of `sat' is the same as
   // the number of rows of `source'; also, the number of rows of `sat'
   // is the same as the number of rows of `dest'.
   PPL_ASSERT(source_num_rows == sat.num_columns());
   PPL_ASSERT(dest_num_rows == sat.num_rows());
 
   // If `start > 0', then we are converting the pending constraints.
   PPL_ASSERT(start == 0 || start == source.first_pending_row());
 
   PPL_DIRTY_TEMP_COEFFICIENT(normalized_sp_i);
   PPL_DIRTY_TEMP_COEFFICIENT(normalized_sp_o);
 
   bool dest_sorted = dest.is_sorted();
   const dimension_type dest_first_pending_row = dest.first_pending_row();
 
   // This will contain the row indexes of the redundant rows of `source'.
   std::vector<dimension_type> redundant_source_rows;
 
 #if PPL_QUICK_ADJ_TEST
   // This will contain the number of ones in each row of `sat'.
   PPL_DIRTY_TEMP(std::vector<dimension_type>, sat_num_ones);
   sat_num_ones.resize(dest_num_rows, 0);
   for (dimension_type i = dest_num_rows; i-- > 0; ) {
     sat_num_ones[i] = sat[i].count_ones();
   }
 #endif // PPL_QUICK_ADJ_TEST
 
   // Converting the sub-system of `source' having rows with indexes
   // from `start' to the last one (i.e., `source_num_rows' - 1).
   for (dimension_type k = start; k < source_num_rows; ++k) {
     const source_row_type& source_k = source[k];
 
 #ifndef NDEBUG
 #if PPL_QUICK_ADJ_TEST
     for (dimension_type i = dest_num_rows; i-- > 0; ) {
       PPL_ASSERT(sat_num_ones[i] == sat[i].count_ones());
     }
 #endif // PPL_QUICK_ADJ_TEST
 #endif // NDEBUG
 
     // `scalar_prod[i]' will contain the scalar product of the
     // constraint `source_k' and the generator `dest_rows[i]'.  This
     // product is 0 if and only if the generator saturates the
     // constraint.
     PPL_DIRTY_TEMP(std::vector<Coefficient>, scalar_prod);
     if (dest_num_rows > scalar_prod.size()) {
       scalar_prod.insert(scalar_prod.end(),
                          dest_num_rows - scalar_prod.size(),
                          Coefficient_zero());
     }
     // `index_non_zero' will indicate the first generator in `dest_rows'
     // that does not saturate the constraint `source_k'.
     dimension_type index_non_zero = 0;
     for ( ; index_non_zero < dest_num_rows; ++index_non_zero) {
       WEIGHT_BEGIN();
       Scalar_Products::assign(scalar_prod[index_non_zero],
                               source_k,
                               dest.sys.rows[index_non_zero]);
       WEIGHT_ADD_MUL(17, source_space_dim);
       if (scalar_prod[index_non_zero] != 0) {
         // The generator does not saturate the constraint.
         break;
       }
       // Check if the client has requested abandoning all expensive
       // computations.  If so, the exception specified by the client
       // is thrown now.
       maybe_abandon();
     }
     for (dimension_type i = index_non_zero + 1; i < dest_num_rows; ++i) {
       WEIGHT_BEGIN();
       Scalar_Products::assign(scalar_prod[i], source_k, dest.sys.rows[i]);
       WEIGHT_ADD_MUL(25, source_space_dim);
       // Check if the client has requested abandoning all expensive
       // computations.  If so, the exception specified by the client
       // is thrown now.
       maybe_abandon();
     }
 
     // We first treat the case when `index_non_zero' is less than
     // `num_lines_or_equalities', i.e., when the generator that
     // does not saturate the constraint `source_k' is a line.
     // The other case (described later) is when all the lines
     // in `dest_rows' (i.e., all the rows having indexes less than
     // `num_lines_or_equalities') do saturate the constraint.
 
     if (index_non_zero < num_lines_or_equalities) {
       // Since the generator `dest_rows[index_non_zero]' does not saturate
       // the constraint `source_k', it can no longer be a line
       // (see saturation rule in Section \ref prelims).
       // Therefore, we first transform it to a ray.
       dest.sys.rows[index_non_zero].set_is_ray_or_point_or_inequality();
       // Of the two possible choices, we select the ray satisfying
       // the constraint (namely, the ray whose scalar product
       // with the constraint gives a positive result).
       if (scalar_prod[index_non_zero] < 0) {
         // The ray `dest_rows[index_non_zero]' lies on the wrong half-space:
         // we change it to have the opposite direction.
         neg_assign(scalar_prod[index_non_zero]);
         neg_assign(dest.sys.rows[index_non_zero].expr);
         // The modified row may still not be OK(), so don't assert OK here.
         // They are all checked at the end of this function.
       }
       // Having changed a line to a ray, we set `dest_rows' to be a
       // non-sorted system, we decrement the number of lines of `dest_rows'
       // and, if necessary, we move the new ray below all the remaining lines.
       dest_sorted = false;
       --num_lines_or_equalities;
       if (index_non_zero != num_lines_or_equalities) {
         swap(dest.sys.rows[index_non_zero],
              dest.sys.rows[num_lines_or_equalities]);
         swap(scalar_prod[index_non_zero],
              scalar_prod[num_lines_or_equalities]);
       }
       const dest_row_type& dest_nle = dest.sys.rows[num_lines_or_equalities];
 
       // Computing the new lineality space.
       // Since each line must lie on the hyper-plane corresponding to
       // the constraint `source_k', the scalar product between
       // the line and the constraint must be 0.
       // This property already holds for the lines having indexes
       // between 0 and `index_non_zero' - 1.
       // We have to consider the remaining lines, having indexes
       // between `index_non_zero' and `num_lines_or_equalities' - 1.
       // Each line that does not saturate the constraint has to be
       // linearly combined with generator `dest_nle' so that the
       // resulting new line saturates the constraint.
       // Note that, by Observation 1 above, the resulting new line
       // will still saturate all the constraints that were saturated by
       // the old line.
 
       Coefficient& scalar_prod_nle = scalar_prod[num_lines_or_equalities];
       PPL_ASSERT(scalar_prod_nle != 0);
       for (dimension_type
              i = index_non_zero; i < num_lines_or_equalities; ++i) {
         if (scalar_prod[i] != 0) {
           // The following fragment optimizes the computation of
           //
           // <CODE>
           //   Coefficient scale = scalar_prod[i];
           //   scale.gcd_assign(scalar_prod_nle);
           //   Coefficient normalized_sp_i = scalar_prod[i] / scale;
           //   Coefficient normalized_sp_n = scalar_prod_nle / scale;
           //   for (dimension_type c = dest_num_columns; c-- > 0; ) {
           //     dest[i][c] *= normalized_sp_n;
           //     dest[i][c] -= normalized_sp_i * dest_nle[c];
           //   }
           // </CODE>
           normalize2(scalar_prod[i],
                      scalar_prod_nle,
                      normalized_sp_i,
                      normalized_sp_o);
           dest_row_type& dest_i = dest.sys.rows[i];
           neg_assign(normalized_sp_i);
           dest_i.expr.linear_combine(dest_nle.expr,
                                      normalized_sp_o, normalized_sp_i);
           dest_i.strong_normalize();
           // The modified row may still not be OK(), so don't assert OK here.
           // They are all checked at the end of this function.
           scalar_prod[i] = 0;
           // dest_sorted has already been set to false.
         }
       }
 
       // Computing the new pointed cone.
       // Similarly to what we have done during the computation of
       // the lineality space, we consider all the remaining rays
       // (having indexes strictly greater than `num_lines_or_equalities')
       // that do not saturate the constraint `source_k'. These rays
       // are positively combined with the ray `dest_nle' so that the
       // resulting new rays saturate the constraint.
       for (dimension_type
              i = num_lines_or_equalities + 1; i < dest_num_rows; ++i) {
         if (scalar_prod[i] != 0) {
           // The following fragment optimizes the computation of
           //
           // <CODE>
           //   Coefficient scale = scalar_prod[i];
           //   scale.gcd_assign(scalar_prod_nle);
           //   Coefficient normalized_sp_i = scalar_prod[i] / scale;
           //   Coefficient normalized_sp_n = scalar_prod_nle / scale;
           //   for (dimension_type c = dest_num_columns; c-- > 0; ) {
           //     dest[i][c] *= normalized_sp_n;
           //     dest[i][c] -= normalized_sp_i * dest_nle[c];
           //   }
           // </CODE>
           normalize2(scalar_prod[i],
                      scalar_prod_nle,
                      normalized_sp_i,
                      normalized_sp_o);
           dest_row_type& dest_i = dest.sys.rows[i];
           WEIGHT_BEGIN();
           neg_assign(normalized_sp_i);
           dest_i.expr.linear_combine(dest_nle.expr,
                                      normalized_sp_o, normalized_sp_i);
           dest_i.strong_normalize();
           // The modified row may still not be OK(), so don't assert OK here.
           // They are all checked at the end of this function.
           scalar_prod[i] = 0;
           // `dest_sorted' has already been set to false.
           WEIGHT_ADD_MUL(41, source_space_dim);
         }
         // Check if the client has requested abandoning all expensive
         // computations.  If so, the exception specified by the client
         // is thrown now.
         maybe_abandon();
       }
       // Since the `scalar_prod_nle' is positive (by construction), it
       // does not saturate the constraint `source_k'.  Therefore, if
       // the constraint is an inequality, we set to 1 the
       // corresponding element of `sat' ...
       Bit_Row& sat_nle = sat[num_lines_or_equalities];
       if (source_k.is_ray_or_point_or_inequality()) {
         sat_nle.set(k - redundant_source_rows.size());
 #if PPL_QUICK_ADJ_TEST
         ++sat_num_ones[num_lines_or_equalities];
 #endif // PPL_QUICK_ADJ_TEST
       }
       else {
         // ... otherwise, the constraint is an equality which is
         // violated by the generator `dest_nle': the generator has to be
         // removed from `dest_rows'.
         --dest_num_rows;
         swap(dest.sys.rows[num_lines_or_equalities],
              dest.sys.rows[dest_num_rows]);
         recyclable_dest_rows.resize(recyclable_dest_rows.size() + 1);
         swap(dest.sys.rows.back(), recyclable_dest_rows.back());
         dest.sys.rows.pop_back();
         PPL_ASSERT(dest_num_rows == dest.sys.rows.size());
 
         swap(scalar_prod_nle, scalar_prod[dest_num_rows]);
         swap(sat_nle, sat[dest_num_rows]);
 #if PPL_QUICK_ADJ_TEST
         swap(sat_num_ones[num_lines_or_equalities],
              sat_num_ones[dest_num_rows]);
 #endif // PPL_QUICK_ADJ_TEST
         // dest_sorted has already been set to false.
       }
       // Finished handling the line or equality case:
       // continue with next `k'.
       continue;
     }
 
     // Here all the lines in `dest_rows' saturate the constraint `source_k'.
     PPL_ASSERT(index_non_zero >= num_lines_or_equalities);
     // First, we reorder the generators in `dest_rows' as follows:
     // -# all the lines should have indexes between 0 and
     //    `num_lines_or_equalities' - 1 (this already holds);
     // -# all the rays that saturate the constraint should have
     //    indexes between `num_lines_or_equalities' and
     //    `lines_or_equal_bound' - 1; these rays form the set Q=.
     // -# all the rays that have a positive scalar product with the
     //    constraint should have indexes between `lines_or_equal_bound'
     //    and `sup_bound' - 1; these rays form the set Q+.
     // -# all the rays that have a negative scalar product with the
     //    constraint should have indexes between `sup_bound' and
     //    `dest_num_rows' - 1; these rays form the set Q-.
     dimension_type lines_or_equal_bound = num_lines_or_equalities;
     dimension_type inf_bound = dest_num_rows;
     // While we find saturating generators, we simply increment
     // `lines_or_equal_bound'.
     while (inf_bound > lines_or_equal_bound
            && scalar_prod[lines_or_equal_bound] == 0) {
       ++lines_or_equal_bound;
     }
     dimension_type sup_bound = lines_or_equal_bound;
     while (inf_bound > sup_bound) {
       const int sp_sign = sgn(scalar_prod[sup_bound]);
       if (sp_sign == 0) {
         // This generator has to be moved in Q=.
         swap(dest.sys.rows[sup_bound], dest.sys.rows[lines_or_equal_bound]);
         swap(scalar_prod[sup_bound], scalar_prod[lines_or_equal_bound]);
         swap(sat[sup_bound], sat[lines_or_equal_bound]);
 #if PPL_QUICK_ADJ_TEST
         swap(sat_num_ones[sup_bound], sat_num_ones[lines_or_equal_bound]);
 #endif // PPL_QUICK_ADJ_TEST
         ++lines_or_equal_bound;
         ++sup_bound;
         dest_sorted = false;
       }
       else if (sp_sign < 0) {
         // This generator has to be moved in Q-.
         --inf_bound;
         swap(dest.sys.rows[sup_bound], dest.sys.rows[inf_bound]);
         swap(sat[sup_bound], sat[inf_bound]);
         swap(scalar_prod[sup_bound], scalar_prod[inf_bound]);
 #if PPL_QUICK_ADJ_TEST
         swap(sat_num_ones[sup_bound], sat_num_ones[inf_bound]);
 #endif // PPL_QUICK_ADJ_TEST
         dest_sorted = false;
       }
       else {
         // sp_sign > 0: this generator has to be moved in Q+.
         ++sup_bound;
       }
     }
 
     if (sup_bound == dest_num_rows) {
       // Here the set Q- is empty.
       // If the constraint is an inequality, then all the generators
       // in Q= and Q+ satisfy the constraint. The constraint is redundant
       // and it can be safely removed from the constraint system.
       // This is why the `source' parameter is not declared `const'.
       if (source_k.is_ray_or_point_or_inequality()) {
         redundant_source_rows.push_back(k);
       }
       else {
         // The constraint is an equality, so that all the generators
         // in Q+ violate it. Since the set Q- is empty, we can simply
         // remove from `dest_rows' all the generators of Q+.
         PPL_ASSERT(dest_num_rows >= lines_or_equal_bound);
         while (dest_num_rows != lines_or_equal_bound) {
           recyclable_dest_rows.resize(recyclable_dest_rows.size() + 1);
           swap(dest.sys.rows.back(), recyclable_dest_rows.back());
           dest.sys.rows.pop_back();
           --dest_num_rows;
           }
         PPL_ASSERT(dest_num_rows == dest.sys.rows.size());
       }
       // Finished handling the case when Q- is empty:
       // continue with next `k'.
       continue;
     }
 
     // The set Q- is not empty, i.e., at least one generator
     // violates the constraint `source_k'.
     if (sup_bound == num_lines_or_equalities) {
       // The set Q+ is empty, so that all generators that satisfy
       // the constraint also saturate it.
       // We can simply remove from `dest_rows' all the generators in Q-.
       PPL_ASSERT(dest_num_rows >= sup_bound);
       while (dest_num_rows != sup_bound) {
         recyclable_dest_rows.resize(recyclable_dest_rows.size() + 1);
         swap(dest.sys.rows.back(), recyclable_dest_rows.back());
         dest.sys.rows.pop_back();
         --dest_num_rows;
       }
       PPL_ASSERT(dest_num_rows == dest.sys.rows.size());
       // Finished handling the case when Q+ is empty:
       // continue with next `k'.
       continue;
     }
 
     // The sets Q+ and Q- are both non-empty.
     // The generators of the new pointed cone are all those satisfying
     // the constraint `source_k' plus a set of new rays enjoying
     // the following properties:
     // -# they lie on the hyper-plane represented by the constraint
     // -# they are obtained as a positive combination of two
     //    adjacent rays, the first taken from Q+ and the second
     //    taken from Q-.
 
     const dimension_type bound = dest_num_rows;
 
 #if PPL_QUICK_NON_ADJ_TEST
     // For the quick non-adjacency test, we refer to the definition
     // of a minimal proper face (see comments in Polyhedron_defs.hh):
     // an extremal ray saturates at least `n' - `t' - 1 constraints,
     // where `n' is the dimension of the space and `t' is the dimension
     // of the lineality space. Since `n == source_num_columns - 1' and
     // `t == num_lines_or_equalities', we obtain that an extremal ray
     // saturates at least `source_num_columns - num_lines_or_equalities - 2'
     // constraints.
     const dimension_type min_saturators
       = source_num_columns - num_lines_or_equalities - 2;
     // NOTE: we are treating the `k'-th constraint.
     const dimension_type max_saturators = k - redundant_source_rows.size();
 #endif // PPL_QUICK_NON_ADJ_TEST
 
     // In the following loop,
     // `i' runs through the generators in the set Q+ and
     // `j' runs through the generators in the set Q-.
     for (dimension_type i = lines_or_equal_bound; i < sup_bound; ++i) {
       for (dimension_type j = sup_bound; j < bound; ++j) {
         // Checking if generators `dest_rows[i]' and `dest_rows[j]' are
         // adjacent.
         // If there exist another generator that saturates
         // all the constraints saturated by both `dest_rows[i]' and
         // `dest_rows[j]', then they are NOT adjacent.
         PPL_ASSERT(sat[i].last() == C_Integer<unsigned long>::max
                    || sat[i].last() < k);
         PPL_ASSERT(sat[j].last() == C_Integer<unsigned long>::max
                    || sat[j].last() < k);
 
         // Being the union of `sat[i]' and `sat[j]',
         // `new_satrow' corresponds to a ray that saturates all the
         // constraints saturated by both `dest_rows[i]' and
         // `dest_rows[j]'.
         Bit_Row new_satrow(sat[i], sat[j]);
 
         // Even before actually creating the new ray as a
         // positive combination of `dest_rows[i]' and `dest_rows[j]',
         // we exploit saturation information to perform:
         //  - a quick non-adjacency test;
         //  - a quick adjacency test.
 
 #if (PPL_QUICK_NON_ADJ_TEST || PPL_QUICK_ADJ_TEST)
         // Compute the number of common saturators.
         dimension_type new_satrow_ones = new_satrow.count_ones();
 #endif // (PPL_QUICK_NON_ADJ_TEST || PPL_QUICK_ADJ_TEST)
 
 #if PPL_QUICK_NON_ADJ_TEST
         const dimension_type num_common_satur
           = max_saturators - new_satrow_ones;
         if (num_common_satur < min_saturators) {
           // Quick non-adjacency test succeded: consider next `j'.
           continue;
         }
 #endif // PPL_QUICK_NON_ADJ_TEST
 
 #if PPL_QUICK_ADJ_TEST
         // If either `sat[i]' or `sat[j]' has exactly one more zeroes
         // than `new_satrow', then `dest_rows[i]' and `dest_rows[j]'
         // are adjacent. Equivalently, adjacency holds if `new_satrow_ones'
         // is equal to 1 plus the maximum of `sat_num_ones[i]' and
         // `sat_num_ones[j]'.
         const dimension_type max_ones_i_j
           = std::max(sat_num_ones[i], sat_num_ones[j]);
         if (max_ones_i_j + 1 == new_satrow_ones) {
           // Quick adjacency test succeded: skip the full test.
           goto are_adjacent;
         }
 #endif // PPL_QUICK_ADJ_TEST
 
         // Perform the full (combinatorial) adjacency test.
         {
           bool redundant = false;
           WEIGHT_BEGIN();
           for (dimension_type l = num_lines_or_equalities; l < bound; ++l) {
             if (l != i && l != j
                 && subset_or_equal(sat[l], new_satrow)) {
               // Found another generator saturating all the constraints
               // saturated by both `dest_rows[i]' and `dest_rows[j]'.
               redundant = true;
               break;
             }
           }
           PPL_ASSERT(bound >= num_lines_or_equalities);
           WEIGHT_ADD_MUL(15, bound - num_lines_or_equalities);
           if (redundant) {
             // Full non-adjacency test succeded: consider next `j'.
             continue;
           }
         }
 
 #if PPL_QUICK_ADJ_TEST
       are_adjacent:
 #endif // PPL_QUICK_ADJ_TEST
         // Adding the new ray to `dest_rows' and the corresponding
         // saturation row to `sat'.
         dest_row_type new_row;
         if (recyclable_dest_rows.empty()) {
           sat.add_recycled_row(new_satrow);
 #if PPL_QUICK_ADJ_TEST
           sat_num_ones.push_back(new_satrow_ones);
 #endif // PPL_QUICK_ADJ_TEST
         }
         else {
           swap(new_row, recyclable_dest_rows.back());
           recyclable_dest_rows.pop_back();
           new_row.set_space_dimension_no_ok(source_space_dim);
           swap(sat[dest_num_rows], new_satrow);
 #if PPL_QUICK_ADJ_TEST
           swap(sat_num_ones[dest_num_rows], new_satrow_ones);
 #endif // PPL_QUICK_ADJ_TEST
         }
 
         // The following fragment optimizes the computation of
         //
         // <CODE>
         //   Coefficient scale = scalar_prod[i];
         //   scale.gcd_assign(scalar_prod[j]);
         //   Coefficient normalized_sp_i = scalar_prod[i] / scale;
         //   Coefficient normalized_sp_j = scalar_prod[j] / scale;
         //   for (dimension_type c = dest_num_columns; c-- > 0; ) {
         //     new_row[c] = normalized_sp_i * dest[j][c];
         //     new_row[c] -= normalized_sp_j * dest[i][c];
         //   }
         // </CODE>
         normalize2(scalar_prod[i],
                    scalar_prod[j],
                    normalized_sp_i,
                    normalized_sp_o);
         WEIGHT_BEGIN();
 
         neg_assign(normalized_sp_o);
         new_row = dest.sys.rows[j];
         // TODO: Check if the following assertions hold.
         PPL_ASSERT(normalized_sp_i != 0);
         PPL_ASSERT(normalized_sp_o != 0);
         new_row.expr.linear_combine(dest.sys.rows[i].expr,
                                     normalized_sp_i, normalized_sp_o);
 
         WEIGHT_ADD_MUL(86, source_space_dim);
         new_row.strong_normalize();
         // Don't assert new_row.OK() here, because it may fail if
         // the parameter `dest' contained a row that wasn't ok.
         // Since we added a new generator to `dest_rows',
         // we also add a new element to `scalar_prod';
         // by construction, the new ray lies on the hyper-plane
         // represented by the constraint `source_k'.
         // Thus, the added scalar product is 0.
         PPL_ASSERT(scalar_prod.size() >= dest_num_rows);
         if (scalar_prod.size() <= dest_num_rows) {
           scalar_prod.push_back(Coefficient_zero());
         }
         else {
           scalar_prod[dest_num_rows] = Coefficient_zero();
         }
         dest.sys.rows.resize(dest.sys.rows.size() + 1);
         swap(dest.sys.rows.back(), new_row);
         // Increment the number of generators.
         ++dest_num_rows;
       } // End of loop on `j'.
       // Check if the client has requested abandoning all expensive
       // computations.  If so, the exception specified by the client
       // is thrown now.
       maybe_abandon();
     } // End of loop on `i'.
     // Now we substitute the rays in Q- (i.e., the rays violating
     // the constraint) with the newly added rays.
     dimension_type j;
     if (source_k.is_ray_or_point_or_inequality()) {
       // The constraint is an inequality:
       // the violating generators are those in Q-.
       j = sup_bound;
       // For all the generators in Q+, set to 1 the corresponding
       // entry for the constraint `source_k' in the saturation matrix.
 
       // After the removal of redundant rows in `source', the k-th
       // row will have index `new_k'.
       const dimension_type new_k = k - redundant_source_rows.size();
       for (dimension_type l = lines_or_equal_bound;
            l < sup_bound; ++l) {
         sat[l].set(new_k);
 #if PPL_QUICK_ADJ_TEST
         ++sat_num_ones[l];
 #endif // PPL_PPL_QUICK_ADJ_TEST
       }
     }
     else {
       // The constraint is an equality:
       // the violating generators are those in the union of Q+ and Q-.
       j = lines_or_equal_bound;
     }
     // Swapping the newly added rays
     // (index `i' running through `dest_num_rows - 1' down-to `bound')
     // with the generators violating the constraint
     // (index `j' running through `j' up-to `bound - 1').
     dimension_type i = dest_num_rows;
     while (j < bound && i > bound) {
       --i;
       swap(dest.sys.rows[i], dest.sys.rows[j]);
       swap(scalar_prod[i], scalar_prod[j]);
       swap(sat[i], sat[j]);
 #if PPL_QUICK_ADJ_TEST
       swap(sat_num_ones[i], sat_num_ones[j]);
 #endif // PPL_QUICK_ADJ_TEST
       ++j;
       dest_sorted = false;
     }
     // Setting the number of generators in `dest':
     // - if the number of generators violating the constraint
     //   is less than or equal to the number of the newly added
     //   generators, we assign `i' to `dest_num_rows' because
     //   all generators above this index are significant;
     // - otherwise, we assign `j' to `dest_num_rows' because
     //   all generators below index `j-1' violates the constraint.
     const dimension_type new_num_rows = (j == bound) ? i : j;
     PPL_ASSERT(dest_num_rows >= new_num_rows);
     while (dest_num_rows != new_num_rows) {
       recyclable_dest_rows.resize(recyclable_dest_rows.size() + 1);
       swap(dest.sys.rows.back(), recyclable_dest_rows.back());
       dest.sys.rows.pop_back();
       --dest_num_rows;
     }
     PPL_ASSERT(dest_num_rows == dest.sys.rows.size());
   } // End of loop on `k'.
 
   // We may have identified some redundant constraints in `source',
   // which have been swapped at the end of the system.
   if (redundant_source_rows.size() > 0) {
     source.remove_rows(redundant_source_rows);
     sat.remove_trailing_columns(redundant_source_rows.size());
   }
 
   // If `start == 0', then `source' was sorted and remained so.
   // If otherwise `start > 0', then the two sub-system made by the
   // non-pending rows and the pending rows, respectively, were both sorted.
   // Thus, the overall system is sorted if and only if either
   // `start == source_num_rows' (i.e., the second sub-system is empty)
   // or the row ordering holds for the two rows at the boundary between
   // the two sub-systems.
   if (start > 0 && start < source.num_rows()) {
     source.set_sorted(compare(source[start - 1], source[start]) <= 0);
   }
   // There are no longer pending constraints in `source'.
   source.unset_pending_rows();
 
   // We may have identified some redundant rays in `dest_rows',
   // which have been swapped into recyclable_dest_rows.
   if (!recyclable_dest_rows.empty()) {
     const dimension_type num_removed_rows = recyclable_dest_rows.size();
     sat.remove_trailing_rows(num_removed_rows);
   }
   if (dest_sorted) {
     // If the non-pending generators in `dest' are still declared to be
     // sorted, then we have to also check for the sortedness of the
     // pending generators.
     for (dimension_type i = dest_first_pending_row;
          i < dest_num_rows; ++i) {
       if (compare(dest.sys.rows[i - 1], dest.sys.rows[i]) > 0) {
         dest_sorted = false;
         break;
       }
     }
   }
 #ifndef NDEBUG
   // The previous code can modify the rows' fields, exploiting the friendness.
   // Check that all rows are OK now.
   for (dimension_type i = dest.num_rows(); i-- > 0; ) {
     PPL_ASSERT(dest.sys.rows[i].OK());
   }
 #endif
 
   dest.sys.index_first_pending = dest.num_rows();
   dest.set_sorted(dest_sorted);
   PPL_ASSERT(dest.sys.OK());
 
   return num_lines_or_equalities;
 }

template<typename FP_Format , typename Interval_Info >

void Parma_Polyhedra_Library::Polyhedron::convert_to_integer_expression	(	const Linear_Form< Interval< FP_Format, Interval_Info > > &	lf,
		const dimension_type	lf_dimension,
		Linear_Expression &	result
	)

staticprotected

Helper function that makes result become a Linear_Expression obtained by normalizing the denominators in lf.

Parameters

lf	The linear form on intervals with floating point boundaries to normalize. It should be the result of an application of static method `overapproximate_linear_form`.
lf_dimension	Must be the space dimension of `lf`.
result	Used to store the result.

This function ignores the upper bound of intervals in lf, so that in fact result can be seen as lf multiplied by a proper normalization constant.

Definition at line 476 of file Polyhedron_templates.hh.

References Parma_Polyhedra_Library::exact_div_assign(), Parma_Polyhedra_Library::lcm_assign(), Parma_Polyhedra_Library::numer_denom(), and PPL_DIRTY_TEMP_COEFFICIENT.

Referenced by refine_with_linear_form_inequality().

                                            {
   result = Linear_Expression();
 
   typedef Interval<FP_Format, Interval_Info> FP_Interval_Type;
   std::vector<Coefficient> numerators(lf_dimension+1);
   std::vector<Coefficient> denominators(lf_dimension+1);
 
   // Convert each floating point number to a pair <numerator, denominator>
   // and compute the lcm of all denominators.
   PPL_DIRTY_TEMP_COEFFICIENT(lcm);
   lcm = 1;
   const FP_Interval_Type& b = lf.inhomogeneous_term();
   // FIXME: are these checks numerator[i] != 0 really necessary?
   numer_denom(b.lower(), numerators[lf_dimension],
                          denominators[lf_dimension]);
   if (numerators[lf_dimension] != 0) {
       lcm_assign(lcm, lcm, denominators[lf_dimension]);
   }
 
   for (dimension_type i = 0; i < lf_dimension; ++i) {
     const FP_Interval_Type& curr_int = lf.coefficient(Variable(i));
     numer_denom(curr_int.lower(), numerators[i], denominators[i]);
     if (numerators[i] != 0) {
       lcm_assign(lcm, lcm, denominators[i]);
     }
   }
 
   for (dimension_type i = 0; i < lf_dimension; ++i) {
     if (numerators[i] != 0) {
       exact_div_assign(denominators[i], lcm, denominators[i]);
       numerators[i] *= denominators[i];
       result += numerators[i] * Variable(i);
     }
   }
 
   if (numerators[lf_dimension] != 0) {
     exact_div_assign(denominators[lf_dimension],
                      lcm, denominators[lf_dimension]);
     numerators[lf_dimension] *= denominators[lf_dimension];
     result += numerators[lf_dimension];
   }
 }

template<typename FP_Format , typename Interval_Info >

void Parma_Polyhedra_Library::Polyhedron::convert_to_integer_expressions	(	const Linear_Form< Interval< FP_Format, Interval_Info > > &	lf,
		const dimension_type	lf_dimension,
		Linear_Expression &	res,
		Coefficient &	res_low_coeff,
		Coefficient &	res_hi_coeff,
		Coefficient &	denominator
	)

staticprotected

Normalization helper function.

Parameters

lf	The linear form on intervals with floating point boundaries to normalize. It should be the result of an application of static method `overapproximate_linear_form`.
lf_dimension	Must be the space dimension of `lf`.
res	Stores the normalized linear form, except its inhomogeneous term.
res_low_coeff	Stores the lower boundary of the inhomogeneous term of the result.
res_hi_coeff	Stores the higher boundary of the inhomogeneous term of the result.
denominator	Becomes the common denominator of `res_low_coeff`, `res_hi_coeff` and all coefficients in `res`.

Results are obtained by normalizing denominators in lf, ignoring the upper bounds of variable coefficients in lf.

Definition at line 524 of file Polyhedron_templates.hh.

References Parma_Polyhedra_Library::exact_div_assign(), Parma_Polyhedra_Library::lcm_assign(), and Parma_Polyhedra_Library::numer_denom().

Referenced by affine_form_image().

                                           {
   res = Linear_Expression();
 
   typedef Interval<FP_Format, Interval_Info> FP_Interval_Type;
   std::vector<Coefficient> numerators(lf_dimension+2);
   std::vector<Coefficient> denominators(lf_dimension+2);
 
   // Convert each floating point number to a pair <numerator, denominator>
   // and compute the lcm of all denominators.
   Coefficient& lcm = denominator;
   lcm = 1;
   const FP_Interval_Type& b = lf.inhomogeneous_term();
   numer_denom(b.lower(), numerators[lf_dimension], denominators[lf_dimension]);
   // FIXME: are these checks numerator[i] != 0 really necessary?
   if (numerators[lf_dimension] != 0) {
       lcm_assign(lcm, lcm, denominators[lf_dimension]);
   }
 
   numer_denom(b.upper(), numerators[lf_dimension+1],
                          denominators[lf_dimension+1]);
   if (numerators[lf_dimension+1] != 0) {
       lcm_assign(lcm, lcm, denominators[lf_dimension+1]);
   }
 
   for (dimension_type i = 0; i < lf_dimension; ++i) {
     const FP_Interval_Type& curr_int = lf.coefficient(Variable(i));
     numer_denom(curr_int.lower(), numerators[i], denominators[i]);
     if (numerators[i] != 0) {
       lcm_assign(lcm, lcm, denominators[i]);
     }
   }
 
   for (dimension_type i = 0; i < lf_dimension; ++i) {
     if (numerators[i] != 0) {
       exact_div_assign(denominators[i], lcm, denominators[i]);
       numerators[i] *= denominators[i];
       res += numerators[i] * Variable(i);
     }
   }
 
   if (numerators[lf_dimension] != 0) {
     exact_div_assign(denominators[lf_dimension],
                      lcm, denominators[lf_dimension]);
     numerators[lf_dimension] *= denominators[lf_dimension];
     res_low_coeff = numerators[lf_dimension];
   }
   else {
     res_low_coeff = 0;
   }
 
   if (numerators[lf_dimension+1] != 0) {
     exact_div_assign(denominators[lf_dimension+1],
                      lcm, denominators[lf_dimension+1]);
     numerators[lf_dimension+1] *= denominators[lf_dimension+1];
     res_hi_coeff = numerators[lf_dimension+1];
   }
   else {
     res_hi_coeff = 0;
   }
 }

void Parma_Polyhedra_Library::Polyhedron::difference_assign ( const Polyhedron & y )

inline

Same as poly_difference_assign(y).

Definition at line 86 of file Polyhedron_inlines.hh.

References poly_difference_assign().

                                                  {
   poly_difference_assign(y);
 }

void Parma_Polyhedra_Library::Polyhedron::drop_some_non_integer_points ( Complexity_Class complexity = ANY_COMPLEXITY )

inline

Possibly tightens *this by dropping some points with non-integer coordinates.

Parameters

complexity The maximal complexity of any algorithms used.

Note: Currently there is no optimality guarantee, not even if complexity is ANY_COMPLEXITY.

Definition at line 442 of file Polyhedron_inlines.hh.

Referenced by drop_some_non_integer_points().

                                                                     {
   const Variables_Set* const p_vs = 0;
   drop_some_non_integer_points(p_vs, complexity);
 }

void Parma_Polyhedra_Library::Polyhedron::drop_some_non_integer_points	(	const Variables_Set &	vars,
		Complexity_Class	complexity = `ANY_COMPLEXITY`
	)

inline

Possibly tightens *this by dropping some points with non-integer coordinates for the space dimensions corresponding to vars.

Parameters

vars	Points with non-integer coordinates for these variables/space-dimensions can be discarded.
complexity	The maximal complexity of any algorithms used.

Note: Currently there is no optimality guarantee, not even if complexity is ANY_COMPLEXITY.

Definition at line 448 of file Polyhedron_inlines.hh.

References drop_some_non_integer_points().

                                                                       {
   drop_some_non_integer_points(&vars, complexity);
 }

void Parma_Polyhedra_Library::Polyhedron::drop_some_non_integer_points	(	const Variables_Set *	vars_p,
		Complexity_Class	complexity
	)

protected

Possibly tightens *this by dropping some points with non-integer coordinates for the space dimensions corresponding to *vars_p.

Parameters

vars_p	When nonzero, points with non-integer coordinates for the variables/space-dimensions contained in `*vars_p` can be discarded.
complexity	The maximal complexity of any algorithms used.

Note: Currently there is no optimality guarantee, not even if complexity is ANY_COMPLEXITY.

Definition at line 2232 of file Polyhedron_nonpublic.cc.

                                                                            {
   // There is nothing to do for an empty set of variables.
   if (vars_p != 0 && vars_p->empty()) {
     return;
   }
 
   // Any empty polyhedron does not contain integer points.
   if (marked_empty()) {
     return;
   }
 
   // A zero-dimensional, universe polyhedron has, by convention, an
   // integer point.
   if (space_dim == 0) {
     set_empty();
     return;
   }
 
   // The constraints (possibly with pending rows) are required.
   if (has_pending_generators()) {
     // Processing of pending generators is exponential in the worst case.
     if (complexity != ANY_COMPLEXITY) {
       return;
     }
     else {
       process_pending_generators();
     }
   }
   if (!constraints_are_up_to_date()) {
     // Constraints update is exponential in the worst case.
     if (complexity != ANY_COMPLEXITY) {
       return;
     }
     else {
       update_constraints();
     }
   }
   // For NNC polyhedra we need to process any pending constraints.
   if (!is_necessarily_closed() && has_pending_constraints()) {
     if (complexity != ANY_COMPLEXITY) {
       return;
     }
     else if (!process_pending_constraints()) {
       // We just discovered the polyhedron is empty.
       return;
     }
   }
 
   PPL_ASSERT(!has_pending_generators() && constraints_are_up_to_date());
   PPL_ASSERT(is_necessarily_closed() || !has_pending_constraints());
 
   bool changed = false;
   PPL_DIRTY_TEMP_COEFFICIENT(gcd);
 
   const bool con_sys_was_sorted = con_sys.is_sorted();
 
   Variables_Set other_vars;
   if (vars_p != 0) {
     // Compute the complement of `*vars_p'.
     for (dimension_type i = 0; i < space_dim; ++i) {
       if (vars_p->find(i) == vars_p->end()) {
         other_vars.insert(Variable(i));
       }
     }
   }
 
   for (dimension_type j = con_sys.sys.rows.size(); j-- > 0; ) {
     Constraint& c = con_sys.sys.rows[j];
     if (c.is_tautological()) {
       continue;
     }
     if (!other_vars.empty()) {
       // Skip constraints having a nonzero coefficient for a variable
       // that does not occurr in the input set.
       if (!c.expression().all_zeroes(other_vars)) {
         continue;
       }
     }
 
     if (!is_necessarily_closed()) {
       // Transform all strict inequalities into non-strict ones,
       // with the inhomogeneous term incremented by 1.
       if (c.epsilon_coefficient() < 0) {
         c.set_epsilon_coefficient(0);
         Linear_Expression& e = c.expr;
         e.set_inhomogeneous_term(e.inhomogeneous_term() - 1);
         // Enforce normalization.
         // FIXME: is this really necessary?
         e.normalize();
         PPL_ASSERT(c.OK());
         changed = true;
       }
     }
 
     // Compute the GCD of all the homogeneous terms.
     gcd = c.expression().gcd(1, space_dim + 1);
 
     if (gcd != 0 && gcd != 1) {
       PPL_ASSERT(c.expr.inhomogeneous_term() % gcd != 0);
 
       // If we have an equality, the polyhedron becomes empty.
       if (c.is_equality()) {
         set_empty();
         return;
       }
 
       // Divide the inhomogeneous coefficients by the GCD.
       c.expr.exact_div_assign(gcd, 1, space_dim + 1);
 
       PPL_DIRTY_TEMP_COEFFICIENT(c_0);
       c_0 = c.expr.inhomogeneous_term();
       const int c_0_sign = sgn(c_0);
       c_0 /= gcd;
       if (c_0_sign < 0) {
         --c_0;
       }
       c.expr.set_inhomogeneous_term(c_0);
       PPL_ASSERT(c.OK());
       changed = true;
     }
   }
 
   con_sys.set_sorted(!changed && con_sys_was_sorted);
   PPL_ASSERT(con_sys.sys.OK());
 
   if (changed) {
     if (is_necessarily_closed()) {
       con_sys.insert(Constraint::zero_dim_positivity());
     }
     else {
       con_sys.insert(Constraint::epsilon_leq_one());
     }
     // After changing the system of constraints, the generators
     // are no longer up-to-date and the constraints are no longer
     // minimized.
     clear_generators_up_to_date();
     clear_constraints_minimized();
   }
   PPL_ASSERT_HEAVY(OK());
 }

void Parma_Polyhedra_Library::Polyhedron::expand_space_dimension	(	Variable	var,
		dimension_type	m
	)

Creates m copies of the space dimension corresponding to var.

Parameters

var	The variable corresponding to the space dimension to be replicated;
m	The number of replicas to be created.

Exceptions

std::invalid_argument	Thrown if `var` does not correspond to a dimension of the vector space.
std::length_error	Thrown if adding `m` new space dimensions would cause the vector space to exceed dimension `max_space_dimension()`.

If *this has space dimension $n$ , with $n > 0$ , and var has space dimension $k \leq n$ , then the $k$ -th space dimension is expanded to m new space dimensions $n$ , $n+1$ , $\dots$ , $n+m-1$ .

Definition at line 401 of file Polyhedron_chdims.cc.

                                                                     {
   // `var' should be one of the dimensions of the vector space.
   if (var.space_dimension() > space_dim) {
     throw_dimension_incompatible("expand_space_dimension(v, m)", "v", var);
   }
 
   // The space dimension of the resulting polyhedron should not
   // overflow the maximum allowed space dimension.
   check_space_dimension_overflow(m, max_space_dimension() - space_dimension(),
                                  topology(),
                                  "expand_dimension(v, m)",
                                  "adding m new space dimensions exceeds "
                                  "the maximum allowed space dimension");
 
   // Nothing to do, if no dimensions must be added.
   if (m == 0) {
     return;
   }
 
   // Keep track of the dimension before adding the new ones.
   const dimension_type old_dim = space_dim;
 
   // Add the required new dimensions.
   add_space_dimensions_and_embed(m);
 
   const Constraint_System& cs = constraints();
   Constraint_System new_constraints(cs.topology());
   for (Constraint_System::const_iterator i = cs.begin(),
          cs_end = cs.end(); i != cs_end; ++i) {
     const Constraint& c = *i;
 
     Coefficient_traits::const_reference coeff = c.coefficient(var);
 
     // If `c' does not constrain `var', skip it.
     if (coeff == 0) {
       continue;
     }
 
     Constraint c_template = c;
     c_template.expr.set_coefficient(var, Coefficient_zero());
 
     // Each relevant constraint results in `m' new constraints.
     for (dimension_type dst_d = old_dim; dst_d < old_dim+m; ++dst_d) {
       Constraint new_c = c_template;
       add_mul_assign(new_c.expr, coeff, Variable(dst_d));
       PPL_ASSERT(new_c.OK());
       new_constraints.insert(new_c, Recycle_Input());
     }
   }
   add_recycled_constraints(new_constraints);
   PPL_ASSERT_HEAVY(OK());
 }

PPL::memory_size_type Parma_Polyhedra_Library::Polyhedron::external_memory_in_bytes ( ) const

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

Definition at line 4049 of file Polyhedron_public.cc.

Referenced by total_memory_in_bytes().

                                               {
   return
     con_sys.external_memory_in_bytes()
     + gen_sys.external_memory_in_bytes()
     + sat_c.external_memory_in_bytes()
     + sat_g.external_memory_in_bytes();
 }

void Parma_Polyhedra_Library::Polyhedron::finalize ( )

static

Finalizes the class.

Definition at line 54 of file Polyhedron_public.cc.

Referenced by Parma_Polyhedra_Library::Init::~Init().

                         {
   delete [] simplify_num_saturators_p;
   simplify_num_saturators_p = 0;
   simplify_num_saturators_size = 0;
 }

void Parma_Polyhedra_Library::Polyhedron::fold_space_dimensions	(	const Variables_Set &	vars,
		Variable	dest
	)

Folds the space dimensions in vars into dest.

Parameters

vars	The set of Variable objects corresponding to the space dimensions to be folded;
dest	The variable corresponding to the space dimension that is the destination of the folding operation.

Exceptions

std::invalid_argument Thrown if *this is dimension-incompatible with dest or with one of the Variable objects contained in vars. Also thrown if dest is contained in vars.

If *this has space dimension $n$ , with $n > 0$ , dest has space dimension $k \leq n$ , vars is a set of variables whose maximum space dimension is also less than or equal to $n$ , and dest is not a member of vars, then the space dimensions corresponding to variables in vars are folded into the $k$ -th space dimension.

Definition at line 455 of file Polyhedron_chdims.cc.

References affine_image(), Parma_Polyhedra_Library::Variable::id(), Parma_Polyhedra_Library::Variables_Set::space_dimension(), and Parma_Polyhedra_Library::Variable::space_dimension().

                                                       {
   // TODO: this implementation is _really_ an executable specification.
 
   // `dest' should be one of the dimensions of the polyhedron.
   if (dest.space_dimension() > space_dim) {
     throw_dimension_incompatible("fold_space_dimensions(vs, v)", "v", dest);
   }
 
   // The folding of no dimensions is a no-op.
   if (vars.empty()) {
     return;
   }
 
   // All variables in `vars' should be dimensions of the polyhedron.
   if (vars.space_dimension() > space_dim) {
     throw_dimension_incompatible("fold_space_dimensions(vs, v)",
                                  "vs.space_dimension()",
                                  vars.space_dimension());
   }
 
   // Moreover, `dest.id()' should not occur in `vars'.
   if (vars.find(dest.id()) != vars.end()) {
     throw_invalid_argument("fold_space_dimensions(vs, v)",
                            "v should not occur in vs");
   }
 
   // All of the affine images we are going to compute are not invertible,
   // hence we will need to compute the generators of the polyhedron.
   // Since we keep taking copies, make sure that a single conversion
   // from constraints to generators is computed.
   (void) generators();
   // Having generators, we now know if the polyhedron is empty:
   // in that case, folding is equivalent to just removing space dimensions.
   if (!marked_empty()) {
     for (Variables_Set::const_iterator i = vars.begin(),
            vs_end = vars.end(); i != vs_end; ++i) {
       Polyhedron copy = *this;
       copy.affine_image(dest, Linear_Expression(Variable(*i)));
       poly_hull_assign(copy);
     }
   }
   remove_space_dimensions(vars);
   PPL_ASSERT_HEAVY(OK());
 }

bool Parma_Polyhedra_Library::Polyhedron::frequency	(	const Linear_Expression &	expr,
		Coefficient &	freq_n,
		Coefficient &	freq_d,
		Coefficient &	val_n,
		Coefficient &	val_d
	)		const

Returns true if and only if there exist a unique value val such that *this saturates the equality expr = val.

Parameters

expr	The linear expression for which the frequency is needed;
freq_n	If `true` is returned, the value is set to ; Present for interface compatibility with class Grid, where the frequency can have a non-zero value;
freq_d	If `true` is returned, the value is set to ;
val_n	The numerator of `val`;
val_d	The denominator of `val`;

Exceptions

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

If false is returned, then freq_n, freq_d, val_n and val_d are left untouched.

Definition at line 3732 of file Polyhedron_public.cc.

                                                                          {
   // The dimension of `expr' must be at most the dimension of *this.
   if (space_dim < expr.space_dimension()) {
     throw_dimension_incompatible("frequency(e, ...)", "e", expr);
   }
 
   // If the `expr' has a constant value, then the frequency
   // `freq_n' is 0. Otherwise the values for \p expr are not discrete
   // and we return false.
 
   // Space dimension is 0: if empty, then return false;
   // otherwise the frequency is 1 and the value is 0.
   if (space_dim == 0) {
     if (is_empty()) {
       return false;
     }
     freq_n = 0;
     freq_d = 1;
     val_n = expr.inhomogeneous_term();
     val_d = 1;
     return true;
   }
 
   // For an empty polyhedron, we simply return false.
   if (marked_empty()
       || (has_pending_constraints() && !process_pending_constraints())
       || (!generators_are_up_to_date() && !update_generators())) {
     return false;
   }
 
   // The polyhedron has updated, possibly pending generators.
   // The following loop will iterate through the generator
   // to see if `expr' has a constant value.
   PPL_DIRTY_TEMP(mpq_class, value);
 
   // True if we have no other candidate value to compare with.
   bool first_candidate = true;
 
   PPL_DIRTY_TEMP_COEFFICIENT(sp);
   PPL_DIRTY_TEMP(mpq_class, candidate);
   for (dimension_type i = gen_sys.num_rows(); i-- > 0; ) {
     const Generator& gen_sys_i = gen_sys[i];
     Scalar_Products::homogeneous_assign(sp, expr, gen_sys_i);
     // Lines and rays in `*this' can cause `expr' to be non-constant.
     if (gen_sys_i.is_line_or_ray()) {
       const int sp_sign = sgn(sp);
       if (sp_sign != 0) {
         // `expr' is unbounded in `*this'.
         return false;
       }
     }
     else {
       // We have a point or a closure point.
       PPL_ASSERT(gen_sys_i.is_point() || gen_sys_i.is_closure_point());
       // Notice that we are ignoring the constant term in `expr' here.
       // We will add it to the value if there is a constant value.
       assign_r(candidate.get_num(), sp, ROUND_NOT_NEEDED);
       assign_r(candidate.get_den(), gen_sys_i.expr.inhomogeneous_term(), ROUND_NOT_NEEDED);
       candidate.canonicalize();
       if (first_candidate) {
         // We have a (new) candidate value.
         first_candidate = false;
         value = candidate;
       }
       else if (candidate != value) {
         return false;
       }
     }
   }
 
   // Add in the constant term in `expr'.
   PPL_DIRTY_TEMP(mpz_class, n);
   assign_r(n, expr.inhomogeneous_term(), ROUND_NOT_NEEDED);
   value += n;
   val_n = value.get_num();
   val_d = value.get_den();
 
   freq_n = 0;
   freq_d = 1;
   return true;
 }

void Parma_Polyhedra_Library::Polyhedron::generalized_affine_image	(	Variable	var,
		Relation_Symbol	relsym,
		const Linear_Expression &	expr,
		Coefficient_traits::const_reference	denominator = `Coefficient_one()`
	)

Assigns to *this the image of *this with respect to the generalized affine relation $\mathrm{var}' \relsym \frac{\mathrm{expr}}{\mathrm{denominator}}$ , where $\mathord{\relsym}$ is the relation symbol encoded by relsym.

Parameters

var	The left hand side variable of the generalized affine relation;
relsym	The relation symbol;
expr	The numerator of the right hand side affine expression;
denominator	The denominator of the right hand side affine expression (optional argument with default value 1).

Exceptions

std::invalid_argument Thrown if denominator is zero or if expr and *this are dimension-incompatible or if var is not a space dimension of *this or if *this is a C_Polyhedron and relsym is a strict relation symbol.

Definition at line 3082 of file Polyhedron_public.cc.

                                                                         {
   // The denominator cannot be zero.
   if (denominator == 0) {
     throw_invalid_argument("generalized_affine_image(v, r, e, d)", "d == 0");
   }
 
   // Dimension-compatibility checks.
   // The dimension of `expr' should not be greater than the dimension
   // of `*this'.
   if (space_dim < expr.space_dimension()) {
     throw_dimension_incompatible("generalized_affine_image(v, r, e, d)",
                                  "e", expr);
   }
   // `var' should be one of the dimensions of the polyhedron.
   const dimension_type var_space_dim = var.space_dimension();
   if (space_dim < var_space_dim) {
     throw_dimension_incompatible("generalized_affine_image(v, r, e, d)",
                                  "v", var);
   }
 
   // Strict relation symbols are only admitted for NNC polyhedra.
   if (is_necessarily_closed()
       && (relsym == LESS_THAN || relsym == GREATER_THAN)) {
     throw_invalid_argument("generalized_affine_image(v, r, e, d)",
                            "r is a strict relation symbol");
   }
   // The relation symbol cannot be a disequality.
   if (relsym == NOT_EQUAL) {
     throw_invalid_argument("generalized_affine_image(v, r, e, d)",
                            "r is the disequality relation symbol");
   }
 
   // First compute the affine image.
   affine_image(var, expr, denominator);
 
   if (relsym == EQUAL) {
     // The affine relation is indeed an affine function.
     return;
   }
   // Any image of an empty polyhedron is empty.
   // Note: DO check for emptiness here, as we will later add a ray.
   if (is_empty()) {
     return;
   }
 
   switch (relsym) {
   case LESS_OR_EQUAL:
     add_generator(ray(-var));
     break;
   case GREATER_OR_EQUAL:
     add_generator(ray(var));
     break;
   case LESS_THAN:
   // Intentionally fall through.
   case GREATER_THAN:
     {
       // The relation symbol is strict.
       PPL_ASSERT(!is_necessarily_closed());
       // While adding the ray, we minimize the generators
       // in order to avoid adding too many redundant generators later.
       add_generator(ray((relsym == GREATER_THAN) ? var : -var));
       minimize();
 
       // We split each point of the generator system into two generators:
       // a closure point, having the same coordinates of the given point,
       // and another point, having the same coordinates for all but the
       // `var' dimension, which is displaced along the direction of the
       // newly introduced ray.
       for (dimension_type i = gen_sys.num_rows(); i-- > 0; ) {
         const Generator& gen_i = gen_sys.sys.rows[i];
         if (gen_i.is_point()) {
           // Add a copy of `gen_i' at the end of the system.
           // Note: copying is really meant, to avoid undefined behavior.
           gen_sys.sys.rows.push_back(Generator(gen_i));
           // Note: (re-)compute references (invalidated by push_back).
           Generator& old_gen = gen_sys.sys.rows[i];
           Generator& new_gen = gen_sys.sys.rows.back();
           // Transform `old_gen' into a closure point.
           old_gen.set_epsilon_coefficient(0);
           old_gen.expr.normalize();
           PPL_ASSERT(old_gen.OK());
           // Displace `new_gen' by `var' (i.e., along the new ray).
           if (relsym == GREATER_THAN) {
             new_gen.expr += var;
           }
           else {
             new_gen.expr -= var;
           }
           new_gen.expr.normalize();
           PPL_ASSERT(new_gen.OK());
         }
       }
       // Sortedness no longer hold.
       gen_sys.set_sorted(false);
       gen_sys.unset_pending_rows();
       PPL_ASSERT(gen_sys.sys.OK());
 
       clear_constraints_up_to_date();
       clear_generators_minimized();
       clear_sat_c_up_to_date();
       clear_sat_g_up_to_date();
     }
     break;
   default:
     // The EQUAL and NOT_EQUAL cases have been already dealt with.
     PPL_UNREACHABLE;
     break;
   }
   PPL_ASSERT_HEAVY(OK());
 }

void Parma_Polyhedra_Library::Polyhedron::generalized_affine_image	(	const Linear_Expression &	lhs,
		Relation_Symbol	relsym,
		const Linear_Expression &	rhs
	)

Assigns to *this the image of *this with respect to the generalized affine relation $\mathrm{lhs}' \relsym \mathrm{rhs}$ , where $\mathord{\relsym}$ is the relation symbol encoded by relsym.

Parameters

lhs	The left hand side affine expression;
relsym	The relation symbol;
rhs	The right hand side affine expression.

Exceptions

std::invalid_argument Thrown if *this is dimension-incompatible with lhs or rhs or if *this is a C_Polyhedron and relsym is a strict relation symbol.

Definition at line 3306 of file Polyhedron_public.cc.

                                                                         {
   // Dimension-compatibility checks.
   // The dimension of `lhs' should not be greater than the dimension
   // of `*this'.
   dimension_type lhs_space_dim = lhs.space_dimension();
   if (space_dim < lhs_space_dim) {
     throw_dimension_incompatible("generalized_affine_image(e1, r, e2)",
                                  "e1", lhs);
   }
   // The dimension of `rhs' should not be greater than the dimension
   // of `*this'.
   const dimension_type rhs_space_dim = rhs.space_dimension();
   if (space_dim < rhs_space_dim) {
     throw_dimension_incompatible("generalized_affine_image(e1, r, e2)",
                                  "e2", rhs);
   }
 
   // Strict relation symbols are only admitted for NNC polyhedra.
   if (is_necessarily_closed()
       && (relsym == LESS_THAN || relsym == GREATER_THAN)) {
     throw_invalid_argument("generalized_affine_image(e1, r, e2)",
                            "r is a strict relation symbol");
   }
   // The relation symbol cannot be a disequality.
   if (relsym == NOT_EQUAL) {
     throw_invalid_argument("generalized_affine_image(e1, r, e2)",
                            "r is the disequality relation symbol");
   }
   // Any image of an empty polyhedron is empty.
   if (marked_empty()) {
     return;
   }
 
   // Compute the actual space dimension of `lhs',
   // i.e., the highest dimension having a non-zero coefficient in `lhs'.
   lhs_space_dim = lhs.last_nonzero();
 
   // If all variables have a zero coefficient, then `lhs' is a constant:
   // we can simply add the constraint `lhs relsym rhs'.
   if (lhs_space_dim == 0) {
     switch (relsym) {
     case LESS_THAN:
       refine_no_check(lhs < rhs);
       break;
     case LESS_OR_EQUAL:
       refine_no_check(lhs <= rhs);
       break;
     case EQUAL:
       refine_no_check(lhs == rhs);
       break;
     case GREATER_OR_EQUAL:
       refine_no_check(lhs >= rhs);
       break;
     case GREATER_THAN:
       refine_no_check(lhs > rhs);
       break;
     case NOT_EQUAL:
       // The NOT_EQUAL case has been already dealt with.
       PPL_UNREACHABLE;
       break;
     }
     return;
   }
 
   // Gather in `new_lines' the collections of all the lines having
   // the direction of variables occurring in `lhs'.
   // While at it, check whether or not there exists a variable
   // occurring in both `lhs' and `rhs'.
   Generator_System new_lines;
   for (Linear_Expression::const_iterator
       i = lhs.begin(), i_end = lhs.end(); i != i_end; ++i) {
     new_lines.insert(line(i.variable()));
   }
 
   const dimension_type num_common_dims
     = std::min(lhs.space_dimension(), rhs.space_dimension());
   if (lhs.have_a_common_variable(rhs, Variable(0), Variable(num_common_dims))) {
     // Some variables in `lhs' also occur in `rhs'.
     // To ease the computation, we add an additional dimension.
     const Variable new_var(space_dim);
     add_space_dimensions_and_embed(1);
 
     // Constrain the new dimension to be equal to the right hand side.
     // (check for emptiness because we will add lines).
     refine_no_check(new_var == rhs);
     if (!is_empty()) {
       // Existentially quantify the variables in the left hand side.
       add_recycled_generators(new_lines);
 
       // Constrain the new dimension so that it is related to
       // the left hand side as dictated by `relsym'
       // (we force minimization because we will need the generators).
       switch (relsym) {
       case LESS_THAN:
         refine_no_check(lhs < new_var);
         break;
       case LESS_OR_EQUAL:
         refine_no_check(lhs <= new_var);
         break;
       case EQUAL:
         refine_no_check(lhs == new_var);
         break;
       case GREATER_OR_EQUAL:
         refine_no_check(lhs >= new_var);
         break;
       case GREATER_THAN:
         refine_no_check(lhs > new_var);
         break;
       case NOT_EQUAL:
         // The NOT_EQUAL case has been already dealt with.
         PPL_UNREACHABLE;
         break;
       }
     }
     // Remove the temporarily added dimension.
     remove_higher_space_dimensions(space_dim-1);
   }
   else {
     // `lhs' and `rhs' variables are disjoint:
     // there is no need to add a further dimension.
 
     // Any image of an empty polyhedron is empty.
     // Note: DO check for emptiness here, as we will add lines.
     if (is_empty()) {
       return;
     }
 
     // Existentially quantify the variables in the left hand side.
     add_recycled_generators(new_lines);
 
     // Constrain the left hand side expression so that it is related to
     // the right hand side expression as dictated by `relsym'.
     switch (relsym) {
     case LESS_THAN:
       refine_no_check(lhs < rhs);
       break;
     case LESS_OR_EQUAL:
       refine_no_check(lhs <= rhs);
       break;
     case EQUAL:
       refine_no_check(lhs == rhs);
       break;
     case GREATER_OR_EQUAL:
       refine_no_check(lhs >= rhs);
       break;
     case GREATER_THAN:
       refine_no_check(lhs > rhs);
       break;
     case NOT_EQUAL:
       // The NOT_EQUAL case has been already dealt with.
       PPL_UNREACHABLE;
       break;
     }
   }
   PPL_ASSERT_HEAVY(OK());
 }

void Parma_Polyhedra_Library::Polyhedron::generalized_affine_preimage	(	Variable	var,
		Relation_Symbol	relsym,
		const Linear_Expression &	expr,
		Coefficient_traits::const_reference	denominator = `Coefficient_one()`
	)

Assigns to *this the preimage of *this with respect to the generalized affine relation $\mathrm{var}' \relsym \frac{\mathrm{expr}}{\mathrm{denominator}}$ , where $\mathord{\relsym}$ is the relation symbol encoded by relsym.

Parameters

var	The left hand side variable of the generalized affine relation;
relsym	The relation symbol;
expr	The numerator of the right hand side affine expression;
denominator	The denominator of the right hand side affine expression (optional argument with default value 1).

Exceptions

std::invalid_argument Thrown if denominator is zero or if expr and *this are dimension-incompatible or if var is not a space dimension of *this or if *this is a C_Polyhedron and relsym is a strict relation symbol.

Definition at line 3198 of file Polyhedron_public.cc.

                                                                            {
   // The denominator cannot be zero.
   if (denominator == 0) {
     throw_invalid_argument("generalized_affine_preimage(v, r, e, d)",
                            "d == 0");
   }
 
   // Dimension-compatibility checks.
   // The dimension of `expr' should not be greater than the dimension
   // of `*this'.
   if (space_dim < expr.space_dimension()) {
     throw_dimension_incompatible("generalized_affine_preimage(v, r, e, d)",
                                  "e", expr);
   }
   // `var' should be one of the dimensions of the polyhedron.
   const dimension_type var_space_dim = var.space_dimension();
   if (space_dim < var_space_dim) {
     throw_dimension_incompatible("generalized_affine_preimage(v, r, e, d)",
                                  "v", var);
   }
 
   // Strict relation symbols are only admitted for NNC polyhedra.
   if (is_necessarily_closed()
       && (relsym == LESS_THAN || relsym == GREATER_THAN)) {
     throw_invalid_argument("generalized_affine_preimage(v, r, e, d)",
                            "r is a strict relation symbol");
   }
   // The relation symbol cannot be a disequality.
   if (relsym == NOT_EQUAL) {
     throw_invalid_argument("generalized_affine_preimage(v, r, e, d)",
                            "r is the disequality relation symbol");
   }
 
   // Check whether the affine relation is indeed an affine function.
   if (relsym == EQUAL) {
     affine_preimage(var, expr, denominator);
     return;
   }
 
   // Compute the reversed relation symbol to simplify later coding.
   Relation_Symbol reversed_relsym;
   switch (relsym) {
   case LESS_THAN:
     reversed_relsym = GREATER_THAN;
     break;
   case LESS_OR_EQUAL:
     reversed_relsym = GREATER_OR_EQUAL;
     break;
   case GREATER_OR_EQUAL:
     reversed_relsym = LESS_OR_EQUAL;
     break;
   case GREATER_THAN:
     reversed_relsym = LESS_THAN;
     break;
   default:
     // The EQUAL and NOT_EQUAL cases have been already dealt with.
     PPL_UNREACHABLE;
     return;
   }
 
   // Check whether the preimage of this affine relation can be easily
   // computed as the image of its inverse relation.
   const Coefficient& var_coefficient = expr.coefficient(var);
   if (var_coefficient != 0) {
     const Linear_Expression inverse_expr
       = expr - (denominator + var_coefficient) * var;
     PPL_DIRTY_TEMP_COEFFICIENT(inverse_denominator);
     neg_assign(inverse_denominator, var_coefficient);
     const Relation_Symbol inverse_relsym
       = (sgn(denominator) == sgn(inverse_denominator))
       ? relsym : reversed_relsym;
     generalized_affine_image(var, inverse_relsym, inverse_expr,
                              inverse_denominator);
     return;
   }
 
   // Here `var_coefficient == 0', so that the preimage cannot
   // be easily computed by inverting the affine relation.
   // Shrink the polyhedron by adding the constraint induced
   // by the affine relation.
   const Relation_Symbol corrected_relsym
     = (denominator > 0) ? relsym : reversed_relsym;
   switch (corrected_relsym) {
   case LESS_THAN:
     refine_no_check(denominator*var < expr);
     break;
   case LESS_OR_EQUAL:
     refine_no_check(denominator*var <= expr);
     break;
   case GREATER_OR_EQUAL:
     refine_no_check(denominator*var >= expr);
     break;
   case GREATER_THAN:
     refine_no_check(denominator*var > expr);
     break;
   default:
     // The EQUAL and NOT_EQUAL cases have been already dealt with.
     PPL_UNREACHABLE;
     break;
   }
   unconstrain(var);
   PPL_ASSERT_HEAVY(OK());
 }

void Parma_Polyhedra_Library::Polyhedron::generalized_affine_preimage	(	const Linear_Expression &	lhs,
		Relation_Symbol	relsym,
		const Linear_Expression &	rhs
	)

Assigns to *this the preimage of *this with respect to the generalized affine relation $\mathrm{lhs}' \relsym \mathrm{rhs}$ , where $\mathord{\relsym}$ is the relation symbol encoded by relsym.

Parameters

lhs	The left hand side affine expression;
relsym	The relation symbol;
rhs	The right hand side affine expression.

Exceptions

std::invalid_argument Thrown if *this is dimension-incompatible with lhs or rhs or if *this is a C_Polyhedron and relsym is a strict relation symbol.

Definition at line 3466 of file Polyhedron_public.cc.

                                                                            {
   // Dimension-compatibility checks.
   // The dimension of `lhs' should not be greater than the dimension
   // of `*this'.
   dimension_type lhs_space_dim = lhs.space_dimension();
   if (space_dim < lhs_space_dim) {
     throw_dimension_incompatible("generalized_affine_preimage(e1, r, e2)",
                                  "e1", lhs);
   }
   // The dimension of `rhs' should not be greater than the dimension
   // of `*this'.
   const dimension_type rhs_space_dim = rhs.space_dimension();
   if (space_dim < rhs_space_dim) {
     throw_dimension_incompatible("generalized_affine_preimage(e1, r, e2)",
                                  "e2", rhs);
   }
 
   // Strict relation symbols are only admitted for NNC polyhedra.
   if (is_necessarily_closed()
       && (relsym == LESS_THAN || relsym == GREATER_THAN)) {
     throw_invalid_argument("generalized_affine_preimage(e1, r, e2)",
                            "r is a strict relation symbol");
   }
   // The relation symbol cannot be a disequality.
   if (relsym == NOT_EQUAL) {
     throw_invalid_argument("generalized_affine_preimage(e1, r, e2)",
                            "r is the disequality relation symbol");
   }
   // Any preimage of an empty polyhedron is empty.
   if (marked_empty()) {
     return;
   }
 
   // Compute the actual space dimension of `lhs',
   // i.e., the highest dimension having a non-zero coefficient in `lhs'.
   lhs_space_dim = lhs.last_nonzero();
 
   // If all variables have a zero coefficient, then `lhs' is a constant:
   // in this case, preimage and image happen to be the same.
   if (lhs_space_dim == 0) {
     generalized_affine_image(lhs, relsym, rhs);
     return;
   }
 
   // Gather in `new_lines' the collections of all the lines having
   // the direction of variables occurring in `lhs'.
   // While at it, check whether or not there exists a variable
   // occurring in both `lhs' and `rhs'.
   Generator_System new_lines;
   for (Linear_Expression::const_iterator
       i = lhs.begin(), i_end = lhs.end(); i != i_end; ++i) {
     new_lines.insert(line(i.variable()));
   }
 
   const dimension_type num_common_dims
     = std::min(lhs.space_dimension(), rhs.space_dimension());
   if (lhs.have_a_common_variable(rhs, Variable(0), Variable(num_common_dims))) {
     // Some variables in `lhs' also occur in `rhs'.
     // To ease the computation, we add an additional dimension.
     const Variable new_var(space_dim);
     add_space_dimensions_and_embed(1);
 
     // Constrain the new dimension to be equal to `lhs'
     // (also check for emptiness because we have to add lines).
     refine_no_check(new_var == lhs);
     if (!is_empty()) {
       // Existentially quantify the variables in the left hand side.
       add_recycled_generators(new_lines);
 
       // Constrain the new dimension so that it is related to
       // the right hand side as dictated by `relsym'.
       switch (relsym) {
       case LESS_THAN:
         refine_no_check(new_var < rhs);
         break;
       case LESS_OR_EQUAL:
         refine_no_check(new_var <= rhs);
         break;
       case EQUAL:
         refine_no_check(new_var == rhs);
         break;
       case GREATER_OR_EQUAL:
         refine_no_check(new_var >= rhs);
         break;
       case GREATER_THAN:
         refine_no_check(new_var > rhs);
         break;
       case NOT_EQUAL:
         // The NOT_EQUAL case has been already dealt with.
         PPL_UNREACHABLE;
         break;
       }
     }
     // Remove the temporarily added dimension.
     remove_higher_space_dimensions(space_dim-1);
   }
   else {
     // `lhs' and `rhs' variables are disjoint:
     // there is no need to add a further dimension.
 
     // Constrain the left hand side expression so that it is related to
     // the right hand side expression as dictated by `relsym'.
     switch (relsym) {
     case LESS_THAN:
       refine_no_check(lhs < rhs);
       break;
     case LESS_OR_EQUAL:
       refine_no_check(lhs <= rhs);
       break;
     case EQUAL:
       refine_no_check(lhs == rhs);
       break;
     case GREATER_OR_EQUAL:
       refine_no_check(lhs >= rhs);
       break;
     case GREATER_THAN:
       refine_no_check(lhs > rhs);
       break;
     case NOT_EQUAL:
       // The NOT_EQUAL case has been already dealt with.
       PPL_UNREACHABLE;
       break;
     }
     // Any image of an empty polyhedron is empty.
     // Note: DO check for emptiness here, as we will add lines.
     if (is_empty()) {
       return;
     }
     // Existentially quantify all the variables occurring in `lhs'.
     add_recycled_generators(new_lines);
   }
   PPL_ASSERT_HEAVY(OK());
 }

template<typename FP_Format , typename Interval_Info >

void Parma_Polyhedra_Library::Polyhedron::generalized_refine_with_linear_form_inequality	(	const Linear_Form< Interval< FP_Format, Interval_Info > > &	left,
		const Linear_Form< Interval< FP_Format, Interval_Info > > &	right,
		Relation_Symbol	relsym
	)

inline

Refines *this with the constraint expressed by left $\relsym$ right, where $\relsym$ is the relation symbol specified by relsym..

Parameters

left	The linear form on intervals with floating point boundaries that is on the left of the comparison operator. All of its coefficients MUST be bounded.
right	The linear form on intervals with floating point boundaries that is on the right of the comparison operator. All of its coefficients MUST be bounded.
relsym	The relation symbol.

Exceptions

std::invalid_argument	Thrown if `left` (or `right`) is dimension-incompatible with `*this`.
std::runtime_error	Thrown if `relsym` is not a valid relation symbol.

This function is used in abstract interpretation to model a filter that is generated by a comparison of two expressions that are correctly approximated by left and right respectively.

Definition at line 383 of file Polyhedron_inlines.hh.

References Parma_Polyhedra_Library::EQUAL, Parma_Polyhedra_Library::GREATER_OR_EQUAL, Parma_Polyhedra_Library::GREATER_THAN, Parma_Polyhedra_Library::LESS_OR_EQUAL, Parma_Polyhedra_Library::LESS_THAN, Parma_Polyhedra_Library::NOT_EQUAL, and refine_with_linear_form_inequality().

                                           {
   switch (relsym) {
   case EQUAL:
     // TODO: see if we can handle this case more efficiently.
     refine_with_linear_form_inequality(left, right, false);
     refine_with_linear_form_inequality(right, left, false);
     break;
   case LESS_THAN:
     refine_with_linear_form_inequality(left, right, true);
     break;
   case LESS_OR_EQUAL:
     refine_with_linear_form_inequality(left, right, false);
     break;
   case GREATER_THAN:
     refine_with_linear_form_inequality(right, left, true);
     break;
   case GREATER_OR_EQUAL:
     refine_with_linear_form_inequality(right, left, false);
     break;
   case NOT_EQUAL:
     break;
   default:
     PPL_UNREACHABLE;
     break;
   }
 }

const PPL::Generator_System & Parma_Polyhedra_Library::Polyhedron::generators ( ) const

Returns the system of generators.

Definition at line 138 of file Polyhedron_public.cc.

References Parma_Polyhedra_Library::Generator_System::adjust_topology_and_space_dimension(), Parma_Polyhedra_Library::swap(), and Parma_Polyhedra_Library::Generator_System::zero_dim_univ().

Referenced by Parma_Polyhedra_Library::Termination_Helpers::all_affine_ranking_functions_PR(), Parma_Polyhedra_Library::Termination_Helpers::all_affine_ranking_functions_PR_original(), Parma_Polyhedra_Library::BD_Shape< T >::BD_Shape(), Parma_Polyhedra_Library::Box< ITV >::Box(), Parma_Polyhedra_Library::Grid::Grid(), map_space_dimensions(), and Parma_Polyhedra_Library::Octagonal_Shape< T >::Octagonal_Shape().

                                 {
   if (marked_empty()) {
     PPL_ASSERT(gen_sys.has_no_rows());
     // We want `gen_sys' to have the appropriate space dimension,
     // even though it is an empty generator system.
     if (gen_sys.space_dimension() != space_dim) {
       Generator_System gs;
       gs.adjust_topology_and_space_dimension(topology(), space_dim);
       swap(const_cast<Generator_System&>(gen_sys), gs);
     }
     return gen_sys;
   }
 
   if (space_dim == 0) {
     PPL_ASSERT(gen_sys.num_rows() == 0 && gen_sys.space_dimension() == 0);
     return Generator_System::zero_dim_univ();
   }
 
   // If the polyhedron has pending constraints, we process them to obtain
   // the generators (we may discover that the polyhedron is empty).
   // No processing is needed if the polyhedron has pending generators.
   if ((has_pending_constraints() && !process_pending_constraints())
       || (!generators_are_up_to_date() && !update_generators())) {
     // We have just discovered that `*this' is empty.
     PPL_ASSERT(gen_sys.has_no_rows());
     // We want `gen_sys' to have the appropriate space dimension,
     // even though it is an empty generator system.
     if (gen_sys.space_dimension() != space_dim) {
       Generator_System gs;
       gs.adjust_topology_and_space_dimension(topology(), space_dim);
       swap(const_cast<Generator_System&>(gen_sys), gs);
     }
     return gen_sys;
   }
 
   // TODO: reconsider whether to really sort generators at this stage.
 #if ENSURE_SORTEDNESS
   // We insist in returning a sorted system of generators,
   // but sorting is useless if there are pending generators.
   if (!has_pending_generators())
     obtain_sorted_generators();
 #else
   // In the case of an NNC polyhedron, if the generator system is fully
   // minimized (i.e., minimized and with no pending generator), then
   // return a sorted system of generators: this is needed so that the
   // const_iterator could correctly filter out the matched closure points.
   if (!is_necessarily_closed()
       && generators_are_minimized() && !has_pending_generators()) {
     obtain_sorted_generators();
   }
 #endif
   return gen_sys;
 }

bool Parma_Polyhedra_Library::Polyhedron::generators_are_minimized ( ) const

inlineprivate

Returns true if the system of generators is minimized.

Note that only weak minimization is entailed, so that an NNC polyhedron may still have $\epsilon$ -redundant generators.

Definition at line 150 of file Polyhedron_inlines.hh.

References status, and Parma_Polyhedra_Library::Polyhedron::Status::test_g_minimized().

Referenced by BHRZ03_combining_constraints(), BHRZ03_evolving_points(), BHRZ03_evolving_rays(), can_have_something_pending(), quick_equivalence_test(), and simplify_using_context_assign().

                                            {
   return status.test_g_minimized();
 }

bool Parma_Polyhedra_Library::Polyhedron::generators_are_up_to_date ( ) const

inlineprivate

Returns true if the system of generators is up-to-date.

Definition at line 140 of file Polyhedron_inlines.hh.

References status, and Parma_Polyhedra_Library::Polyhedron::Status::test_g_up_to_date().

Referenced by add_space_dimensions_and_embed(), Parma_Polyhedra_Library::BD_Shape< T >::BD_Shape(), Parma_Polyhedra_Library::Box< ITV >::Box(), Parma_Polyhedra_Library::Grid::Grid(), is_empty(), limited_BHRZ03_extrapolation_assign(), limited_H79_extrapolation_assign(), map_space_dimensions(), Parma_Polyhedra_Library::Octagonal_Shape< T >::Octagonal_Shape(), operator=(), poly_hull_assign(), Polyhedron(), positive_time_elapse_assign_impl(), select_H79_constraints(), and time_elapse_assign().

                                             {
   return status.test_g_up_to_date();
 }

void Parma_Polyhedra_Library::Polyhedron::H79_widening_assign	(	const Polyhedron &	y,
		unsigned *	tp = `0`
	)

Assigns to *this the result of computing the H79_widening between *this and y.

Parameters

y	A polyhedron that must be contained in `*this`;
tp	An optional pointer to an unsigned variable storing the number of available tokens (to be used when applying the widening with tokens delay technique).

Exceptions

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

Definition at line 165 of file Polyhedron_widenings.cc.

References add_recycled_constraints(), con_sys, constraints_are_up_to_date(), contains(), Parma_Polyhedra_Library::Constraint_System::has_no_rows(), has_pending_generators(), intersection_assign(), is_empty(), is_necessarily_closed(), m_swap(), marked_empty(), minimize(), Parma_Polyhedra_Library::Constraint_System::num_equalities(), Parma_Polyhedra_Library::Constraint_System::num_rows(), OK(), process_pending_generators(), select_CH78_constraints(), select_H79_constraints(), space_dim, throw_dimension_incompatible(), throw_topology_incompatible(), topology(), Parma_Polyhedra_Library::UNIVERSE, and update_constraints().

Referenced by Parma_Polyhedra_Library::BD_Shape< T >::H79_widening_assign(), limited_H79_extrapolation_assign(), and widening_assign().

                                                                     {
   Polyhedron& x = *this;
   // Topology compatibility check.
   const Topology topol = x.topology();
   if (topol != y.topology()) {
     throw_topology_incompatible("H79_widening_assign(y)", "y", y);
   // Dimension-compatibility check.
   }
   if (x.space_dim != y.space_dim) {
     throw_dimension_incompatible("H79_widening_assign(y)", "y", y);
   }
   // Assume `y' is contained in or equal to `x'.
   PPL_EXPECT_HEAVY(copy_contains(x, y));
 
   // If any argument is zero-dimensional or empty,
   // the H79-widening behaves as the identity function.
   if (x.space_dim == 0 || x.marked_empty() || y.marked_empty()) {
     return;
   }
 
   // `y.gen_sys' should be in minimal form and
   // `y.sat_g' should be up-to-date.
   if (y.is_necessarily_closed()) {
     if (!y.minimize()) {
       // `y' is empty: the result is `x'.
       return;
     }
   }
   else {
     // Dealing with a NNC polyhedron.
     // To obtain a correct reasoning when comparing
     // the constraints of `x' with the generators of `y',
     // we enforce the inclusion relation holding between
     // the two NNC polyhedra `x' and `y' (i.e., `y <= x')
     // to also hold for the corresponding eps-representations:
     // this is obtained by intersecting the two eps-representations.
     Polyhedron& yy = const_cast<Polyhedron&>(y);
     yy.intersection_assign(x);
     if (yy.is_empty()) {
       // The result is `x'.
       return;
     }
   }
 
   // If we only have the generators of `x' and the dimensions of
   // the two polyhedra are the same, we can compute the standard
   // widening by using the specification in [CousotH78], therefore
   // avoiding converting from generators to constraints.
   if (x.has_pending_generators() || !x.constraints_are_up_to_date()) {
     Constraint_System CH78_cs(topol);
     x.select_CH78_constraints(y, CH78_cs);
 
     if (CH78_cs.num_rows() == y.con_sys.num_rows()) {
       // Having selected all the constraints, the result is `y'.
       x = y;
       return;
     }
     // Otherwise, check if `x' and `y' have the same dimension.
     // Note that `y.con_sys' is minimized and `CH78_cs' has no redundant
     // constraints, since it is a subset of the former.
     else if (CH78_cs.num_equalities() == y.con_sys.num_equalities()) {
       // Let `x' be defined by the constraints in `CH78_cs'.
       Polyhedron CH78(topol, x.space_dim, UNIVERSE);
       CH78.add_recycled_constraints(CH78_cs);
 
       // Check whether we are using the widening-with-tokens technique
       // and there still are tokens available.
       if (tp != 0 && *tp > 0) {
         // There are tokens available. If `CH78' is not a subset of `x',
         // then it is less precise and we use one of the available tokens.
         if (!x.contains(CH78)) {
           --(*tp);
         }
       }
       else {
         // No tokens.
         x.m_swap(CH78);
       }
       PPL_ASSERT_HEAVY(x.OK(true));
       return;
     }
   }
 
   // As the dimension of `x' is strictly greater than the dimension of `y',
   // we have to compute the standard widening by selecting a subset of
   // the constraints of `x'.
   // `x.con_sys' is just required to be up-to-date, because:
   // - if `x.con_sys' is unsatisfiable, then by assumption
   //   also `y' is empty, so that the resulting polyhedron is `x';
   // - redundant constraints in `x.con_sys' do not affect the result
   //   of the widening, because if they are selected they will be
   //   redundant even in the result.
   if (has_pending_generators()) {
     process_pending_generators();
   }
   else if (!x.constraints_are_up_to_date()) {
     x.update_constraints();
   }
   // Copy into `H79_cs' the constraints of `x' that are common to `y',
   // according to the definition of the H79 widening.
   Constraint_System H79_cs(topol);
   Constraint_System x_minus_H79_cs(topol);
   x.select_H79_constraints(y, H79_cs, x_minus_H79_cs);
 
   if (x_minus_H79_cs.has_no_rows()) {
     // We selected all of the constraints of `x',
     // thus the result of the widening is `x'.
     return;
   }
   else {
     // We selected a strict subset of the constraints of `x'.
     // NOTE: as `x.con_sys' was not necessarily in minimal form,
     // this does not imply that the result strictly includes `x'.
     // Let `H79' be defined by the constraints in `H79_cs'.
     Polyhedron H79(topol, x.space_dim, UNIVERSE);
     H79.add_recycled_constraints(H79_cs);
 
     // Check whether we are using the widening-with-tokens technique
     // and there still are tokens available.
     if (tp != 0 && *tp > 0) {
       // There are tokens available. If `H79' is not a subset of `x',
       // then it is less precise and we use one of the available tokens.
       if (!x.contains(H79)) {
         --(*tp);
       }
     }
     else {
       // No tokens.
       x.m_swap(H79);
     }
     PPL_ASSERT_HEAVY(x.OK(true));
   }
 }

bool Parma_Polyhedra_Library::Polyhedron::has_pending_constraints ( ) const

inlineprivate

Returns true if there are pending constraints.

Definition at line 165 of file Polyhedron_inlines.hh.

References status, and Parma_Polyhedra_Library::Polyhedron::Status::test_c_pending().

Referenced by Parma_Polyhedra_Library::BD_Shape< T >::BD_Shape(), Parma_Polyhedra_Library::Box< ITV >::Box(), intersection_assign(), is_empty(), limited_BHRZ03_extrapolation_assign(), limited_H79_extrapolation_assign(), map_space_dimensions(), Parma_Polyhedra_Library::Octagonal_Shape< T >::Octagonal_Shape(), poly_hull_assign(), positive_time_elapse_assign_impl(), process_pending(), remove_pending_to_obtain_constraints(), remove_pending_to_obtain_generators(), simplified_constraints(), and time_elapse_assign().

                                           {
   return status.test_c_pending();
 }

bool Parma_Polyhedra_Library::Polyhedron::has_pending_generators ( ) const

inlineprivate

Returns true if there are pending generators.

Definition at line 170 of file Polyhedron_inlines.hh.

References status, and Parma_Polyhedra_Library::Polyhedron::Status::test_g_pending().

Referenced by H79_widening_assign(), intersection_assign(), is_included_in(), poly_hull_assign(), process_pending(), remove_pending_to_obtain_constraints(), remove_pending_to_obtain_generators(), and simplify_using_context_assign().

                                          {
   return status.test_g_pending();
 }

bool Parma_Polyhedra_Library::Polyhedron::has_something_pending ( ) const

inlineprivate

Returns true if there are either pending constraints or pending generators.

Definition at line 175 of file Polyhedron_inlines.hh.

References status, Parma_Polyhedra_Library::Polyhedron::Status::test_c_pending(), and Parma_Polyhedra_Library::Polyhedron::Status::test_g_pending().

Referenced by Parma_Polyhedra_Library::BD_Shape< T >::BD_Shape(), BHRZ03_combining_constraints(), BHRZ03_evolving_points(), BHRZ03_evolving_rays(), Parma_Polyhedra_Library::Octagonal_Shape< T >::Octagonal_Shape(), process_pending(), quick_equivalence_test(), select_CH78_constraints(), select_H79_constraints(), and simplify_using_context_assign().

                                         {
   return status.test_c_pending() || status.test_g_pending();
 }

int32_t Parma_Polyhedra_Library::Polyhedron::hash_code ( ) const

inline

Returns a 32-bit hash code for *this.

If x and y are such that x == y, then x.hash_code() == y.hash_code().

Definition at line 45 of file Polyhedron_inlines.hh.

References Parma_Polyhedra_Library::hash_code_from_dimension(), and space_dimension().

                             {
   return hash_code_from_dimension(space_dimension());
 }

void Parma_Polyhedra_Library::Polyhedron::initialize ( )

static

Initializes the class.

Definition at line 47 of file Polyhedron_public.cc.

References simplify_num_saturators_p, and simplify_num_saturators_size.

Referenced by Parma_Polyhedra_Library::Init::Init().

                           {
   PPL_ASSERT(simplify_num_saturators_p == 0);
   PPL_ASSERT(simplify_num_saturators_size == 0);
   simplify_num_saturators_p = new dimension_type[simplify_num_saturators_size];
 }

void Parma_Polyhedra_Library::Polyhedron::intersection_assign ( const Polyhedron & y )

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

Exceptions

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

Definition at line 1986 of file Polyhedron_public.cc.

References can_have_something_pending(), clear_constraints_minimized(), clear_generators_up_to_date(), con_sys, constraints_are_up_to_date(), has_pending_constraints(), has_pending_generators(), Parma_Polyhedra_Library::Constraint_System::insert(), Parma_Polyhedra_Library::Constraint_System::insert_pending(), Parma_Polyhedra_Library::Constraint_System::is_sorted(), marked_empty(), Parma_Polyhedra_Library::Constraint_System::merge_rows_assign(), OK(), process_pending_generators(), set_constraints_pending(), set_empty(), space_dim, topology(), and update_constraints().

Referenced by Parma_Polyhedra_Library::Implementation::Termination::all_affine_ranking_functions_MS(), BHRZ03_evolving_points(), BHRZ03_evolving_rays(), H79_widening_assign(), and is_disjoint_from().

                                                       {
   Polyhedron& x = *this;
   // Topology compatibility check.
   if (x.topology() != y.topology()) {
     throw_topology_incompatible("intersection_assign(y)", "y", y);
   }
   // Dimension-compatibility check.
   if (x.space_dim != y.space_dim) {
     throw_dimension_incompatible("intersection_assign(y)", "y", y);
   }
   // If one of the two polyhedra is empty, the intersection is empty.
   if (x.marked_empty()) {
     return;
   }
   if (y.marked_empty()) {
     x.set_empty();
     return;
   }
 
   // If both polyhedra are zero-dimensional,
   // then at this point they are necessarily non-empty,
   // so that their intersection is non-empty too.
   if (x.space_dim == 0) {
     return;
   }
 
   // Both systems of constraints have to be up-to-date,
   // possibly having pending constraints.
   if (x.has_pending_generators()) {
     x.process_pending_generators();
   }
   else if (!x.constraints_are_up_to_date()) {
     x.update_constraints();
   }
 
   if (y.has_pending_generators()) {
     y.process_pending_generators();
   }
   else if (!y.constraints_are_up_to_date()) {
     y.update_constraints();
   }
 
   // Here both systems are up-to-date and possibly have pending constraints
   // (but they cannot have pending generators).
   PPL_ASSERT(!x.has_pending_generators() && x.constraints_are_up_to_date());
   PPL_ASSERT(!y.has_pending_generators() && y.constraints_are_up_to_date());
 
   // If `x' can support pending constraints,
   // the constraints of `y' are added as pending constraints of `x'.
   if (x.can_have_something_pending()) {
     x.con_sys.insert_pending(y.con_sys);
     x.set_constraints_pending();
   }
   else {
     // `x' cannot support pending constraints.
     // If both constraint systems are (fully) sorted, then we can
     // merge them; otherwise we simply add the second to the first.
     if (x.con_sys.is_sorted()
         && y.con_sys.is_sorted() && !y.has_pending_constraints()) {
       x.con_sys.merge_rows_assign(y.con_sys);
     }
     else {
       x.con_sys.insert(y.con_sys);
     }
     // Generators are no longer up-to-date and constraints are no
     // longer minimized.
     x.clear_generators_up_to_date();
     x.clear_constraints_minimized();
   }
   PPL_ASSERT_HEAVY(x.OK() && y.OK());
 }

bool Parma_Polyhedra_Library::Polyhedron::is_bounded ( ) const

Returns true if and only if *this is a bounded polyhedron.

Definition at line 526 of file Polyhedron_public.cc.

                                 {
   // A zero-dimensional or empty polyhedron is bounded.
   if (space_dim == 0
       || marked_empty()
       || (has_pending_constraints() && !process_pending_constraints())
       || (!generators_are_up_to_date() && !update_generators())) {
     return true;
   }
 
   // If the system of generators contains any line or a ray,
   // then the polyhedron is unbounded.
   for (dimension_type i = gen_sys.num_rows(); i-- > 0; ) {
     if (gen_sys[i].is_line_or_ray()) {
       return false;
     }
   }
 
   // The system of generators is composed only by
   // points and closure points: the polyhedron is bounded.
   return true;
 }

bool Parma_Polyhedra_Library::Polyhedron::is_discrete ( ) const

inline

Returns true if and only if *this is discrete.

Definition at line 69 of file Polyhedron_inlines.hh.

References affine_dimension().

                               {
   return affine_dimension() == 0;
 }

bool Parma_Polyhedra_Library::Polyhedron::is_disjoint_from ( const Polyhedron & y ) const

Returns true if and only if *this and y are disjoint.

Exceptions

std::invalid_argument Thrown if x and y are topology-incompatible or dimension-incompatible.

Definition at line 3958 of file Polyhedron_public.cc.

References intersection_assign(), and is_empty().

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

                                                          {
   Polyhedron z = *this;
   z.intersection_assign(y);
   return z.is_empty();
 }

bool Parma_Polyhedra_Library::Polyhedron::is_empty ( ) const

inline

Returns true if and only if *this is an empty polyhedron.

Definition at line 187 of file Polyhedron_inlines.hh.

References generators_are_up_to_date(), has_pending_constraints(), marked_empty(), and minimize().

Referenced by BFT00_poly_hull_assign_if_exact(), BHZ09_C_poly_hull_assign_if_exact(), BHZ09_NNC_poly_hull_assign_if_exact(), BHZ09_poly_hull_assign_if_exact(), Parma_Polyhedra_Library::Box< ITV >::Box(), Parma_Polyhedra_Library::Pointset_Powerset< PSET >::check_containment(), contains(), Parma_Polyhedra_Library::Grid::Grid(), H79_widening_assign(), is_disjoint_from(), Parma_Polyhedra_Library::Pointset_Powerset< PSET >::linear_partition_aux(), operator<<(), operator==(), Parma_Polyhedra_Library::Pointset_Powerset< PSET >::Pointset_Powerset(), and simplify_using_context_assign().

                            {
   if (marked_empty()) {
     return true;
   }
   // Try a fast-fail test: if generators are up-to-date and
   // there are no pending constraints, then the generator system
   // (since it is well formed) contains a point.
   if (generators_are_up_to_date() && !has_pending_constraints()) {
     return false;
   }
   return !minimize();
 }

bool Parma_Polyhedra_Library::Polyhedron::is_included_in ( const Polyhedron & y ) const

private

Returns true if and only if *this is included in y.

Definition at line 425 of file Polyhedron_nonpublic.cc.

Referenced by BHZ09_C_poly_hull_assign_if_exact(), contains(), and operator==().

                                                        {
   // Private method: the caller must ensure the following.
   PPL_ASSERT(topology() == y.topology());
   PPL_ASSERT(space_dim == y.space_dim);
   PPL_ASSERT(!marked_empty() && !y.marked_empty() && space_dim > 0);
 
   const Polyhedron& x = *this;
 
   // `x' cannot have pending constraints, because we need its generators.
   if (x.has_pending_constraints() && !x.process_pending_constraints()) {
     return true;
   }
   // `y' cannot have pending generators, because we need its constraints.
   if (y.has_pending_generators()) {
     y.process_pending_generators();
   }
 
 #if BE_LAZY
   if (!x.generators_are_up_to_date() && !x.update_generators()) {
     return true;
   }
   if (!y.constraints_are_up_to_date()) {
     y.update_constraints();
   }
 #else
   if (!x.generators_are_minimized()) {
     x.minimize();
   }
   if (!y.constraints_are_minimized()) {
     y.minimize();
   }
 #endif
 
   PPL_ASSERT_HEAVY(x.OK());
   PPL_ASSERT_HEAVY(y.OK());
 
   const Generator_System& gs = x.gen_sys;
   const Constraint_System& cs = y.con_sys;
 
   if (x.is_necessarily_closed()) {
     // When working with necessarily closed polyhedra,
     // `x' is contained in `y' if and only if all the generators of `x'
     // satisfy all the inequalities and saturate all the equalities of `y'.
     // This comes from the definition of a polyhedron as the set of
     // vectors satisfying a constraint system and the fact that all
     // vectors in `x' can be obtained by suitably combining its generators.
     for (dimension_type i = cs.num_rows(); i-- > 0; ) {
       const Constraint& c = cs[i];
       if (c.is_inequality()) {
         for (dimension_type j = gs.num_rows(); j-- > 0; ) {
           const Generator& g = gs[j];
           const int sp_sign = Scalar_Products::sign(c, g);
           if (g.is_line()) {
             if (sp_sign != 0) {
               return false;
             }
           }
           else {
             // `g' is a ray or a point.
             if (sp_sign < 0) {
               return false;
             }
           }
         }
       }
       else {
         // `c' is an equality.
         for (dimension_type j = gs.num_rows(); j-- > 0; ) {
           if (Scalar_Products::sign(c, gs[j]) != 0) {
             return false;
           }
         }
       }
     }
   }
   else {
     // Here we have an NNC polyhedron: using the reduced scalar product,
     // which ignores the epsilon coefficient.
     for (dimension_type i = cs.num_rows(); i-- > 0; ) {
       const Constraint& c = cs[i];
       switch (c.type()) {
       case Constraint::NONSTRICT_INEQUALITY:
         for (dimension_type j = gs.num_rows(); j-- > 0; ) {
           const Generator& g = gs[j];
           const int sp_sign = Scalar_Products::reduced_sign(c, g);
           if (g.is_line()) {
             if (sp_sign != 0) {
               return false;
             }
           }
           else {
             // `g' is a ray or a point or a closure point.
             if (sp_sign < 0) {
               return false;
             }
           }
         }
         break;
       case Constraint::EQUALITY:
         for (dimension_type j = gs.num_rows(); j-- > 0; ) {
           if (Scalar_Products::reduced_sign(c, gs[j]) != 0) {
             return false;
           }
         }
         break;
       case Constraint::STRICT_INEQUALITY:
         for (dimension_type j = gs.num_rows(); j-- > 0; ) {
           const Generator& g = gs[j];
           const int sp_sign = Scalar_Products::reduced_sign(c, g);
           switch (g.type()) {
           case Generator::POINT:
             // If a point violates or saturates a strict inequality
             // (when ignoring the epsilon coefficients) then it is
             // not included in the polyhedron.
             if (sp_sign <= 0) {
               return false;
             }
             break;
           case Generator::LINE:
             // Lines have to saturate all constraints.
             if (sp_sign != 0) {
               return false;
             }
             break;
           case Generator::RAY:
             // Intentionally fall through.
           case Generator::CLOSURE_POINT:
             // The generator is a ray or closure point: usual test.
             if (sp_sign < 0) {
               return false;
             }
             break;
           }
         }
         break;
       }
     }
   }
 
   // Inclusion holds.
   return true;
 }

bool Parma_Polyhedra_Library::Polyhedron::is_necessarily_closed ( ) const

inlineprivate

Returns true if and only if the polyhedron is necessarily closed.

Definition at line 74 of file Polyhedron_inlines.hh.

References con_sys, and Parma_Polyhedra_Library::Constraint_System::is_necessarily_closed().

Referenced by BFT00_poly_hull_assign_if_exact(), Parma_Polyhedra_Library::BHRZ03_Certificate::BHRZ03_Certificate(), BHRZ03_combining_constraints(), BHRZ03_evolving_points(), BHZ09_C_poly_hull_assign_if_exact(), BHZ09_NNC_poly_hull_assign_if_exact(), BHZ09_poly_hull_assign_if_exact(), Parma_Polyhedra_Library::BHRZ03_Certificate::compare(), Parma_Polyhedra_Library::H79_Certificate::compare(), Parma_Polyhedra_Library::H79_Certificate::H79_Certificate(), H79_widening_assign(), Parma_Polyhedra_Library::Interfaces::is_necessarily_closed_for_interfaces(), limited_BHRZ03_extrapolation_assign(), limited_H79_extrapolation_assign(), positive_time_elapse_assign_impl(), refine_with_linear_form_inequality(), select_H79_constraints(), simplify_using_context_assign(), throw_topology_incompatible(), and time_elapse_assign().

                                         {
   // We can check either one of the two matrices.
   // (`con_sys' is slightly better, since it is placed at offset 0.)
   return con_sys.is_necessarily_closed();
 }

bool Parma_Polyhedra_Library::Polyhedron::is_topologically_closed ( ) const

Returns true if and only if *this is a topologically closed subset of the vector space.

Definition at line 549 of file Polyhedron_public.cc.

References Parma_Polyhedra_Library::Generator::is_closure_point(), Parma_Polyhedra_Library::Generator::is_matching_closure_point(), and Parma_Polyhedra_Library::Generator::is_point().

                                              {
   // Necessarily closed polyhedra are trivially closed.
   if (is_necessarily_closed()) {
     return true;
   }
   // Any empty or zero-dimensional polyhedron is closed.
   if (marked_empty()
       || space_dim == 0
       || (has_something_pending() && !process_pending())) {
     return true;
   }
 
   // At this point there are no pending constraints or generators.
   PPL_ASSERT(!has_something_pending());
 
   if (generators_are_minimized()) {
     // A polyhedron is closed if and only if all of its (non-redundant)
     // closure points are matched by a corresponding point.
     const dimension_type n_rows = gen_sys.num_rows();
     const dimension_type n_lines = gen_sys.num_lines();
     for (dimension_type i = n_rows; i-- > n_lines; ) {
       const Generator& gen_sys_i = gen_sys[i];
       if (gen_sys_i.is_closure_point()) {
         bool gen_sys_i_has_no_matching_point = true;
         for (dimension_type j = n_rows; j-- > n_lines; ) {
           const Generator& gen_sys_j = gen_sys[j];
           if (i != j
               && gen_sys_j.is_point()
               && gen_sys_i.is_matching_closure_point(gen_sys_j)) {
             gen_sys_i_has_no_matching_point = false;
             break;
           }
         }
         if (gen_sys_i_has_no_matching_point) {
           return false;
         }
       }
     }
     // All closure points are matched.
     return true;
   }
 
   // A polyhedron is closed if, after strong minimization
   // of its constraint system, it has no strict inequalities.
   strongly_minimize_constraints();
   return marked_empty() || !con_sys.has_strict_inequalities();
 }

bool Parma_Polyhedra_Library::Polyhedron::is_universe ( ) const

Returns true if and only if *this is a universe polyhedron.

Definition at line 388 of file Polyhedron_public.cc.

References Parma_Polyhedra_Library::Expression_Hide_Last< T >::all_homogeneous_terms_are_zero(), Parma_Polyhedra_Library::Constraint::epsilon_coefficient(), Parma_Polyhedra_Library::Constraint::expression(), Parma_Polyhedra_Library::Constraint::inhomogeneous_term(), Parma_Polyhedra_Library::Generator::LINE, and Parma_Polyhedra_Library::Generator::RAY.

Referenced by Parma_Polyhedra_Library::BD_Shape< T >::BD_Shape(), and Parma_Polyhedra_Library::Octagonal_Shape< T >::Octagonal_Shape().

                                  {
   if (marked_empty()) {
     return false;
   }
 
   if (space_dim == 0) {
     return true;
   }
   if (!has_pending_generators() && constraints_are_up_to_date()) {
     // Search for a constraint that is not a tautology.
     for (dimension_type i = con_sys.num_rows(); i-- > 0; ) {
       if (!con_sys[i].is_tautological()) {
         return false;
       }
     }
     // All the constraints are tautologies.
     return true;
   }
 
   PPL_ASSERT(!has_pending_constraints() && generators_are_up_to_date());
 
   // Try a fast-fail test.
   dimension_type num_lines = 0;
   dimension_type num_rays = 0;
   const dimension_type first_pending = gen_sys.first_pending_row();
   for (dimension_type i = first_pending; i-- > 0; ) {
     switch (gen_sys[i].type()) {
     case Generator::RAY:
       ++num_rays;
       break;
     case Generator::LINE:
       ++num_lines;
       break;
     default:
       break;
     }
   }
 
   if (has_pending_generators()) {
     // The non-pending part of `gen_sys' was minimized:
     // a success-first test is possible in this case.
     PPL_ASSERT(generators_are_minimized());
     if (num_lines == space_dim) {
       PPL_ASSERT(num_rays == 0);
       return true;
     }
     PPL_ASSERT(num_lines < space_dim);
     // Now scan the pending generators.
     dimension_type num_pending_lines = 0;
     dimension_type num_pending_rays = 0;
     const dimension_type gs_num_rows = gen_sys.num_rows();
     for (dimension_type i = first_pending; i < gs_num_rows; ++i) {
       switch (gen_sys[i].type()) {
       case Generator::RAY:
         ++num_pending_rays;
         break;
       case Generator::LINE:
         ++num_pending_lines;
         break;
       default:
         break;
       }
     }
     // If no pending rays and lines were found,
     // then it is not the universe polyhedron.
     if (num_pending_rays == 0 && num_pending_lines == 0) {
       return false;
     }
     // Factor away the lines already seen (to be on the safe side,
     // we assume they are all linearly independent).
     if (num_lines + num_pending_lines < space_dim) {
       const dimension_type num_dims_missing
         = space_dim - (num_lines + num_pending_lines);
       // In order to span an n dimensional space (where n = num_dims_missing),
       // at least n+1 rays are needed.
       if (num_rays + num_pending_rays <= num_dims_missing) {
         return false;
       }
     }
   }
   else {
     // There is nothing pending.
     if (generators_are_minimized()) {
       // The exact test is possible.
       PPL_ASSERT(num_rays == 0 || num_lines < space_dim);
       return num_lines == space_dim;
     }
     else {
       // Only the fast-fail test can be computed: in order to span
       // an n dimensional space (where n = space_dim - num_lines),
       // at least n+1 rays are needed.
       if (num_lines < space_dim && num_lines + num_rays <= space_dim) {
         return false;
       }
     }
   }
 
   // We need the polyhedron in minimal form.
   if (has_pending_generators()) {
     process_pending_generators();
   }
   else if (!constraints_are_minimized()) {
     minimize();
   }
   if (is_necessarily_closed()) {
     return con_sys.num_rows() == 1
       && con_sys[0].is_inequality()
       && con_sys[0].is_tautological();
   }
   else {
     // NNC polyhedron.
     if (con_sys.num_rows() != 2
         || con_sys[0].is_equality()
         || con_sys[1].is_equality()) {
       return false;
     }
     else {
       // If the system of constraints contains two rows that
       // are not equalities, we are sure that they are
       // epsilon constraints: in this case we know that
       // the polyhedron is universe.
 #ifndef NDEBUG
       obtain_sorted_constraints();
       const Constraint& eps_leq_one = con_sys[0];
       const Constraint& eps_geq_zero = con_sys[1];
       PPL_ASSERT(eps_leq_one.inhomogeneous_term() > 0
                  && eps_leq_one.epsilon_coefficient() < 0
                  && eps_geq_zero.inhomogeneous_term() == 0
                  && eps_geq_zero.epsilon_coefficient() > 0);
       PPL_ASSERT(eps_leq_one.expression().all_homogeneous_terms_are_zero());
       PPL_ASSERT(eps_geq_zero.expression().all_homogeneous_terms_are_zero());
 #endif
       return true;
     }
   }
 }

void Parma_Polyhedra_Library::Polyhedron::limited_BHRZ03_extrapolation_assign	(	const Polyhedron &	y,
		const Constraint_System &	cs,
		unsigned *	tp = `0`
	)

Assigns to *this the result of computing the limited extrapolation between *this and y using the BHRZ03-widening operator.

Parameters

y	A polyhedron that must be contained in `*this`;
cs	The system of constraints used to improve the widened polyhedron;
tp	An optional pointer to an unsigned variable storing the number of available tokens (to be used when applying the widening with tokens delay technique).

Exceptions

std::invalid_argument Thrown if *this, y and cs are topology-incompatible or dimension-incompatible.

Definition at line 840 of file Polyhedron_widenings.cc.

References add_recycled_constraints(), BHRZ03_widening_assign(), c, gen_sys, generators_are_up_to_date(), has_pending_constraints(), Parma_Polyhedra_Library::Constraint_System::has_strict_inequalities(), Parma_Polyhedra_Library::Constraint_System::insert(), is_necessarily_closed(), marked_empty(), minimize(), Parma_Polyhedra_Library::Constraint_System::num_rows(), process_pending_constraints(), Parma_Polyhedra_Library::Generator_System::satisfied_by_all_generators(), space_dim, Parma_Polyhedra_Library::Constraint_System::space_dimension(), and update_generators().

                                                     {
   Polyhedron& x = *this;
   const dimension_type cs_num_rows = cs.num_rows();
   // If `cs' is empty, we fall back to ordinary, non-limited widening.
   if (cs_num_rows == 0) {
     x.BHRZ03_widening_assign(y, tp);
     return;
   }
 
   // Topology compatibility check.
   if (x.is_necessarily_closed()) {
     if (!y.is_necessarily_closed()) {
       throw_topology_incompatible("limited_BHRZ03_extrapolation_assign(y, cs)",
                                   "y", y);
     }
     if (cs.has_strict_inequalities()) {
       throw_topology_incompatible("limited_BHRZ03_extrapolation_assign(y, cs)",
                                   "cs", cs);
     }
   }
   else if (y.is_necessarily_closed()) {
     throw_topology_incompatible("limited_BHRZ03_extrapolation_assign(y, cs)",
                                 "y", y);
   }
   // Dimension-compatibility check.
   if (x.space_dim != y.space_dim) {
     throw_dimension_incompatible("limited_BHRZ03_extrapolation_assign(y, cs)",
                                  "y", y);
   }
   // `cs' must be dimension-compatible with the two polyhedra.
   const dimension_type cs_space_dim = cs.space_dimension();
   if (x.space_dim < cs_space_dim) {
     throw_dimension_incompatible("limited_BHRZ03_extrapolation_assign(y, cs)",
                                  "cs", cs);
   }
 
   // Assume `y' is contained in or equal to `x'.
   PPL_EXPECT_HEAVY(copy_contains(x, y));
 
   if (y.marked_empty()) {
     return;
   }
   if (x.marked_empty()) {
     return;
   }
 
   // The limited BHRZ03-widening between two polyhedra in a
   // zero-dimensional space is a polyhedron in a zero-dimensional
   // space, too.
   if (x.space_dim == 0) {
     return;
   }
 
   if (!y.minimize()) {
     // We have just discovered that `y' is empty.
     return;
   }
 
   // Update the generators of `x': these are used to select,
   // from the constraints in `cs', those that must be added
   // to the resulting polyhedron.
   if ((x.has_pending_constraints() && !x.process_pending_constraints())
       || (!x.generators_are_up_to_date() && !x.update_generators())) {
     // We have just discovered that `x' is empty.
     return;
   }
 
   Constraint_System new_cs;
   // The constraints to be added must be satisfied by all the
   // generators of `x'. We can disregard `y' because `y <= x'.
   const Generator_System& x_gen_sys = x.gen_sys;
   // Iterate upwards here so as to keep the relative ordering of constraints.
   // Not really an issue: just aesthetics.
   for (dimension_type i = 0; i < cs_num_rows; ++i) {
     const Constraint& c = cs[i];
     if (x_gen_sys.satisfied_by_all_generators(c)) {
       new_cs.insert(c);
     }
   }
   x.BHRZ03_widening_assign(y, tp);
   x.add_recycled_constraints(new_cs);
   PPL_ASSERT_HEAVY(OK());
 }

void Parma_Polyhedra_Library::Polyhedron::limited_H79_extrapolation_assign	(	const Polyhedron &	y,
		const Constraint_System &	cs,
		unsigned *	tp = `0`
	)

Assigns to *this the result of computing the limited extrapolation between *this and y using the H79-widening operator.

Parameters

y	A polyhedron that must be contained in `*this`;
cs	The system of constraints used to improve the widened polyhedron;
tp	An optional pointer to an unsigned variable storing the number of available tokens (to be used when applying the widening with tokens delay technique).

Exceptions

std::invalid_argument Thrown if *this, y and cs are topology-incompatible or dimension-incompatible.

Definition at line 300 of file Polyhedron_widenings.cc.

References add_recycled_constraints(), c, gen_sys, generators_are_up_to_date(), H79_widening_assign(), has_pending_constraints(), Parma_Polyhedra_Library::Constraint_System::has_strict_inequalities(), Parma_Polyhedra_Library::Constraint_System::insert(), is_necessarily_closed(), marked_empty(), minimize(), Parma_Polyhedra_Library::Constraint_System::num_rows(), process_pending_constraints(), Parma_Polyhedra_Library::Generator_System::satisfied_by_all_generators(), space_dim, Parma_Polyhedra_Library::Constraint_System::space_dimension(), and update_generators().

Referenced by Parma_Polyhedra_Library::BD_Shape< T >::limited_H79_extrapolation_assign().

                                                                 {
   Polyhedron& x = *this;
 
   const dimension_type cs_num_rows = cs.num_rows();
   // If `cs' is empty, we fall back to ordinary, non-limited widening.
   if (cs_num_rows == 0) {
     x.H79_widening_assign(y, tp);
     return;
   }
 
   // Topology compatibility check.
   if (x.is_necessarily_closed()) {
     if (!y.is_necessarily_closed()) {
       throw_topology_incompatible("limited_H79_extrapolation_assign(y, cs)",
                                   "y", y);
     }
     if (cs.has_strict_inequalities()) {
       throw_topology_incompatible("limited_H79_extrapolation_assign(y, cs)",
                                   "cs", cs);
     }
   }
   else if (y.is_necessarily_closed()) {
     throw_topology_incompatible("limited_H79_extrapolation_assign(y, cs)",
                                 "y", y);
   }
   // Dimension-compatibility check.
   if (x.space_dim != y.space_dim) {
     throw_dimension_incompatible("limited_H79_extrapolation_assign(y, cs)",
                                  "y", y);
   }
   // `cs' must be dimension-compatible with the two polyhedra.
   const dimension_type cs_space_dim = cs.space_dimension();
   if (x.space_dim < cs_space_dim) {
     throw_dimension_incompatible("limited_H79_extrapolation_assign(y, cs)",
                                  "cs", cs);
   }
   // Assume `y' is contained in or equal to `x'.
   PPL_EXPECT_HEAVY(copy_contains(x, y));
 
   if (y.marked_empty()) {
     return;
   }
   if (x.marked_empty()) {
     return;
   }
   // The limited H79-widening between two polyhedra in a
   // zero-dimensional space is a polyhedron in a zero-dimensional
   // space, too.
   if (x.space_dim == 0) {
     return;
   }
 
   if (!y.minimize()) {
     // We have just discovered that `y' is empty.
     return;
   }
 
   // Update the generators of `x': these are used to select,
   // from the constraints in `cs', those that must be added
   // to the resulting polyhedron.
   if ((x.has_pending_constraints() && !x.process_pending_constraints())
       || (!x.generators_are_up_to_date() && !x.update_generators())) {
     // We have just discovered that `x' is empty.
     return;
   }
 
   Constraint_System new_cs;
   // The constraints to be added must be satisfied by all the
   // generators of `x'.  We can disregard `y' because `y <= x'.
   const Generator_System& x_gen_sys = x.gen_sys;
   // Iterate upwards here so as to keep the relative ordering of constraints.
   // Not really an issue: just aesthetics.
   for (dimension_type i = 0; i < cs_num_rows; ++i) {
     const Constraint& c = cs[i];
     if (x_gen_sys.satisfied_by_all_generators(c)) {
       new_cs.insert(c);
     }
   }
   x.H79_widening_assign(y, tp);
   x.add_recycled_constraints(new_cs);
   PPL_ASSERT_HEAVY(OK());
 }

void Parma_Polyhedra_Library::Polyhedron::m_swap ( Polyhedron & y )

inline

Swaps *this with polyhedron y. (*this and y can be dimension-incompatible.)

Exceptions

std::invalid_argument Thrown if x and y are topology-incompatible.

Definition at line 100 of file Polyhedron_inlines.hh.

References con_sys, gen_sys, sat_c, sat_g, space_dim, status, swap(), Parma_Polyhedra_Library::swap(), throw_topology_incompatible(), and topology().

Referenced by add_space_dimensions_and_embed(), Parma_Polyhedra_Library::Implementation::Termination::all_affine_quasi_ranking_functions_MS(), Parma_Polyhedra_Library::Implementation::Termination::all_affine_ranking_functions_MS(), BHRZ03_combining_constraints(), BHRZ03_evolving_points(), BHRZ03_evolving_rays(), BHRZ03_widening_assign(), H79_widening_assign(), map_space_dimensions(), Parma_Polyhedra_Library::NNC_Polyhedron::operator=(), Parma_Polyhedra_Library::C_Polyhedron::operator=(), and swap().

                                 {
   if (topology() != y.topology()) {
     throw_topology_incompatible("swap(y)", "y", y);
   }
   using std::swap;
   swap(con_sys, y.con_sys);
   swap(gen_sys, y.gen_sys);
   swap(sat_c, y.sat_c);
   swap(sat_g, y.sat_g);
   swap(status, y.status);
   swap(space_dim, y.space_dim);
 }

template<typename Partial_Function >

void Parma_Polyhedra_Library::Polyhedron::map_space_dimensions ( const Partial_Function & pfunc )

Remaps the dimensions of the vector space according to a partial function.

Parameters

pfunc The partial function specifying the destiny of each space dimension.

The template type parameter Partial_Function must provide the following methods.

bool has_empty_codomain() const

returns true if and only if the represented partial function has an empty codomain (i.e., it is always undefined). The has_empty_codomain() method will always be called before the methods below. However, if has_empty_codomain() returns true, none of the functions below will be called.

dimension_type max_in_codomain() const

returns the maximum value that belongs to the codomain of the partial function. The max_in_codomain() method is called at most once.

bool maps(dimension_type i, dimension_type& j) const

Let $f$ be the represented function and $k$ be the value of i. If $f$ is defined in $k$ , then $f(k)$ is assigned to j and true is returned. If $f$ is undefined in $k$ , then false is returned. This method is called at most $n$ times, where $n$ is the dimension of the vector space enclosing the polyhedron.

The result is undefined if pfunc does not encode a partial function with the properties described in the specification of the mapping operator.

Definition at line 153 of file Polyhedron_templates.hh.

                                                               {
   if (space_dim == 0) {
     return;
   }
   if (pfunc.has_empty_codomain()) {
     // All dimensions vanish: the polyhedron becomes zero_dimensional.
     if (marked_empty()
         || (has_pending_constraints()
             && !remove_pending_to_obtain_generators())
         || (!generators_are_up_to_date() && !update_generators())) {
       // Removing all dimensions from the empty polyhedron.
       space_dim = 0;
       con_sys.clear();
     }
     else {
       // Removing all dimensions from a non-empty polyhedron.
       set_zero_dim_univ();
     }
 
     PPL_ASSERT_HEAVY(OK());
     return;
   }
 
   const dimension_type new_space_dimension = pfunc.max_in_codomain() + 1;
 
   if (new_space_dimension == space_dim) {
     // The partial function `pfunc' is indeed total and thus specifies
     // a permutation, that is, a renaming of the dimensions.  For
     // maximum efficiency, we will simply permute the columns of the
     // constraint system and/or the generator system.
 
     std::vector<Variable> cycle;
     cycle.reserve(space_dim);
 
     // Used to mark elements as soon as they are inserted in a cycle.
     std::deque<bool> visited(space_dim);
 
     for (dimension_type i = space_dim; i-- > 0; ) {
       if (visited[i]) {
         continue;
       }
 
       dimension_type j = i;
       do {
         visited[j] = true;
         // The following initialization is only to make the compiler happy.
         dimension_type k = 0;
         if (!pfunc.maps(j, k)) {
           throw_invalid_argument("map_space_dimensions(pfunc)",
                                  " pfunc is inconsistent");
         }
         if (k == j) {
           break;
         }
 
         cycle.push_back(Variable(j));
         // Go along the cycle.
         j = k;
       } while (!visited[j]);
 
       // End of cycle.
 
       // Permute all that is up-to-date.  Notice that the contents of
       // the saturation matrices is unaffected by the permutation of
       // columns: they remain valid, if they were so.
       if (constraints_are_up_to_date()) {
         con_sys.permute_space_dimensions(cycle);
       }
 
       if (generators_are_up_to_date()) {
         gen_sys.permute_space_dimensions(cycle);
       }
 
       cycle.clear();
     }
 
     PPL_ASSERT_HEAVY(OK());
     return;
   }
 
   // If control gets here, then `pfunc' is not a permutation and some
   // dimensions must be projected away.
 
   // If there are pending constraints, using `generators()' we process them.
   const Generator_System& old_gensys = generators();
 
   if (old_gensys.has_no_rows()) {
     // The polyhedron is empty.
     Polyhedron new_polyhedron(topology(), new_space_dimension, EMPTY);
     m_swap(new_polyhedron);
     PPL_ASSERT_HEAVY(OK());
     return;
   }
 
   // Make a local copy of the partial function.
   std::vector<dimension_type> pfunc_maps(space_dim, not_a_dimension());
   for (dimension_type j = space_dim; j-- > 0; ) {
     dimension_type pfunc_j;
     if (pfunc.maps(j, pfunc_j)) {
       pfunc_maps[j] = pfunc_j;
     }
   }
 
   Generator_System new_gensys;
   for (Generator_System::const_iterator i = old_gensys.begin(),
          old_gensys_end = old_gensys.end(); i != old_gensys_end; ++i) {
     const Generator& old_g = *i;
     const Generator::expr_type old_e = old_g.expression();
     Linear_Expression expr;
     expr.set_space_dimension(new_space_dimension);
     bool all_zeroes = true;
     for (Generator::expr_type::const_iterator j = old_e.begin(),
           j_end = old_e.end(); j != j_end; ++j) {
       const dimension_type mapped_id = pfunc_maps[j.variable().id()];
       if (mapped_id != not_a_dimension()) {
         add_mul_assign(expr, *j, Variable(mapped_id));
         all_zeroes = false;
       }
     }
     switch (old_g.type()) {
     case Generator::LINE:
       if (!all_zeroes) {
         new_gensys.insert(line(expr));
       }
       break;
     case Generator::RAY:
       if (!all_zeroes) {
         new_gensys.insert(ray(expr));
       }
       break;
     case Generator::POINT:
       // A point in the origin has all zero homogeneous coefficients.
       new_gensys.insert(point(expr, old_g.divisor()));
       break;
     case Generator::CLOSURE_POINT:
       // A closure point in the origin has all zero homogeneous coefficients.
       new_gensys.insert(closure_point(expr, old_g.divisor()));
       break;
     }
   }
   Polyhedron new_polyhedron(topology(), new_gensys);
   m_swap(new_polyhedron);
   PPL_ASSERT_HEAVY(OK(true));
 }

bool Parma_Polyhedra_Library::Polyhedron::marked_empty ( ) const

inlineprivate

Returns true if the polyhedron is known to be empty.

The return value false does not necessarily implies that *this is non-empty.

Definition at line 130 of file Polyhedron_inlines.hh.

References status, and Parma_Polyhedra_Library::Polyhedron::Status::test_empty().

                                {
   return status.test_empty();
 }

bool Parma_Polyhedra_Library::Polyhedron::max_min	(	const Linear_Expression &	expr,
		bool	maximize,
		Coefficient &	ext_n,
		Coefficient &	ext_d,
		bool &	included,
		Generator &	g
	)		const

private

Maximizes or minimizes expr subject to *this.

Parameters

expr	The linear expression to be maximized or minimized subject to `this`;
maximize	`true` if maximization is what is wanted;
ext_n	The numerator of the extremum value;
ext_d	The denominator of the extremum value;
included	`true` if and only if the extremum of `expr` can actually be reached in `*` this;
g	When maximization or minimization succeeds, will be assigned a point or closure point where `expr` reaches the corresponding extremum value.

Exceptions

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

If *this is empty or expr is not bounded in the appropriate direction, false is returned and ext_n, ext_d, included and g are left untouched.

Definition at line 608 of file Polyhedron_nonpublic.cc.

Referenced by maximize(), and minimize().

                                              {
   // The dimension of `expr' should not be greater than the dimension
   // of `*this'.
   const dimension_type expr_space_dim = expr.space_dimension();
   if (space_dim < expr_space_dim) {
     throw_dimension_incompatible((maximize
                                   ? "maximize(e, ...)"
                                   : "minimize(e, ...)"), "e", expr);
   }
 
   // Deal with zero-dim polyhedra first.
   if (space_dim == 0) {
     if (marked_empty()) {
       return false;
     }
     else {
       ext_n = expr.inhomogeneous_term();
       ext_d = 1;
       included = true;
       g = point();
       return true;
     }
   }
 
   // For an empty polyhedron we simply return false.
   if (marked_empty()
       || (has_pending_constraints() && !process_pending_constraints())
       || (!generators_are_up_to_date() && !update_generators())) {
     return false;
   }
 
   // The polyhedron has updated, possibly pending generators.
   // The following loop will iterate through the generator
   // to find the extremum.
   PPL_DIRTY_TEMP(mpq_class, extremum);
 
   // True if we have no other candidate extremum to compare with.
   bool first_candidate = true;
 
   // To store the position of the current candidate extremum.
   PPL_UNINITIALIZED(dimension_type, ext_position);
 
   // Whether the current candidate extremum is included or not.
   PPL_UNINITIALIZED(bool, ext_included);
 
   PPL_DIRTY_TEMP_COEFFICIENT(sp);
   for (dimension_type i = gen_sys.num_rows(); i-- > 0; ) {
     const Generator& gen_sys_i = gen_sys[i];
     Scalar_Products::homogeneous_assign(sp, expr, gen_sys_i);
     // Lines and rays in `*this' can cause `expr' to be unbounded.
     if (gen_sys_i.is_line_or_ray()) {
       const int sp_sign = sgn(sp);
       if (sp_sign != 0
           && (gen_sys_i.is_line()
               || (maximize && sp_sign > 0)
               || (!maximize && sp_sign < 0))) {
         // `expr' is unbounded in `*this'.
         return false;
       }
     }
     else {
       // We have a point or a closure point.
       PPL_ASSERT(gen_sys_i.is_point() || gen_sys_i.is_closure_point());
       // Notice that we are ignoring the constant term in `expr' here.
       // We will add it to the extremum as soon as we find it.
       PPL_DIRTY_TEMP(mpq_class, candidate);
       assign_r(candidate.get_num(), sp, ROUND_NOT_NEEDED);
       assign_r(candidate.get_den(), gen_sys_i.expr.inhomogeneous_term(), ROUND_NOT_NEEDED);
       candidate.canonicalize();
       const bool g_is_point = gen_sys_i.is_point();
       if (first_candidate
           || (maximize
           && (candidate > extremum
           || (g_is_point
           && !ext_included
           && candidate == extremum)))
           || (!maximize
           && (candidate < extremum
           || (g_is_point
           && !ext_included
           && candidate == extremum)))) {
         // We have a (new) candidate extremum.
         first_candidate = false;
         extremum = candidate;
         ext_position = i;
         ext_included = g_is_point;
       }
     }
   }
 
   // Add in the constant term in `expr'.
   PPL_DIRTY_TEMP(mpz_class, n);
   assign_r(n, expr.inhomogeneous_term(), ROUND_NOT_NEEDED);
   extremum += n;
 
   // The polyhedron is bounded in the right direction and we have
   // computed the extremum: write the result into the caller's structures.
   PPL_ASSERT(!first_candidate);
   ext_n = extremum.get_num();
   ext_d = extremum.get_den();
   included = ext_included;
   g = gen_sys[ext_position];
 
   return true;
 }

dimension_type Parma_Polyhedra_Library::Polyhedron::max_space_dimension ( )

inlinestatic

Returns the maximum space dimension all kinds of Polyhedron can handle.

Definition at line 50 of file Polyhedron_inlines.hh.

References Parma_Polyhedra_Library::Constraint_System::max_space_dimension(), and Parma_Polyhedra_Library::Generator_System::max_space_dimension().

Referenced by add_space_dimensions_and_embed(), check_obj_space_dimension_overflow(), check_space_dimension_overflow(), Parma_Polyhedra_Library::max_space_dimension(), and Polyhedron().

                                 {
   using std::min;
   // One dimension is reserved to have a value of type dimension_type
   // that does not represent a legal dimension.
   return min(std::numeric_limits<dimension_type>::max() - 1,
              min(Constraint_System::max_space_dimension(),
                  Generator_System::max_space_dimension()
                  )
              );
 }

bool Parma_Polyhedra_Library::Polyhedron::maximize	(	const Linear_Expression &	expr,
		Coefficient &	sup_n,
		Coefficient &	sup_d,
		bool &	maximum
	)		const

inline

Returns true if and only if *this is not empty and expr is bounded from above in *this, in which case the supremum value is computed.

Parameters

expr	The linear expression to be maximized subject to `*this`;
sup_n	The numerator of the supremum value;
sup_d	The denominator of the supremum value;
maximum	`true` if and only if the supremum is also the maximum value.

Exceptions

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

If *this is empty or expr is not bounded from above, false is returned and sup_n, sup_d and maximum are left untouched.

Definition at line 324 of file Polyhedron_inlines.hh.

References max_min().

                                           {
   Generator g(point());
   return max_min(expr, true, sup_n, sup_d, maximum, g);
 }

bool Parma_Polyhedra_Library::Polyhedron::maximize	(	const Linear_Expression &	expr,
		Coefficient &	sup_n,
		Coefficient &	sup_d,
		bool &	maximum,
		Generator &	g
	)		const

inline

Returns true if and only if *this is not empty and expr is bounded from above in *this, in which case the supremum value and a point where expr reaches it are computed.

Parameters

expr	The linear expression to be maximized subject to `*this`;
sup_n	The numerator of the supremum value;
sup_d	The denominator of the supremum value;
maximum	`true` if and only if the supremum is also the maximum value;
g	When maximization succeeds, will be assigned the point or closure point where `expr` reaches its supremum value.

Exceptions

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

If *this is empty or expr is not bounded from above, false is returned and sup_n, sup_d, maximum and g are left untouched.

Definition at line 332 of file Polyhedron_inlines.hh.

References max_min().

                                          {
   return max_min(expr, true, sup_n, sup_d, maximum, g);
 }

bool Parma_Polyhedra_Library::Polyhedron::minimize	(	const Linear_Expression &	expr,
		Coefficient &	inf_n,
		Coefficient &	inf_d,
		bool &	minimum
	)		const

inline

Returns true if and only if *this is not empty and expr is bounded from below in *this, in which case the infimum value is computed.

Parameters

expr	The linear expression to be minimized subject to `*this`;
inf_n	The numerator of the infimum value;
inf_d	The denominator of the infimum value;
minimum	`true` if and only if the infimum is also the minimum value.

Exceptions

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

If *this is empty or expr is not bounded from below, false is returned and inf_n, inf_d and minimum are left untouched.

Definition at line 339 of file Polyhedron_inlines.hh.

References max_min().

Referenced by BFT00_poly_hull_assign_if_exact(), Parma_Polyhedra_Library::BHRZ03_Certificate::BHRZ03_Certificate(), BHRZ03_combining_constraints(), BHRZ03_evolving_points(), BHRZ03_evolving_rays(), BHRZ03_widening_assign(), BHZ09_C_poly_hull_assign_if_exact(), BHZ09_NNC_poly_hull_assign_if_exact(), Parma_Polyhedra_Library::BHRZ03_Certificate::compare(), Parma_Polyhedra_Library::H79_Certificate::compare(), Parma_Polyhedra_Library::Grid::Grid(), Parma_Polyhedra_Library::H79_Certificate::H79_Certificate(), H79_widening_assign(), is_included_in(), limited_BHRZ03_extrapolation_assign(), limited_H79_extrapolation_assign(), poly_difference_assign(), and simplify_using_context_assign().

                                           {
   Generator g(point());
   return max_min(expr, false, inf_n, inf_d, minimum, g);
 }

bool Parma_Polyhedra_Library::Polyhedron::minimize	(	const Linear_Expression &	expr,
		Coefficient &	inf_n,
		Coefficient &	inf_d,
		bool &	minimum,
		Generator &	g
	)		const

inline

Returns true if and only if *this is not empty and expr is bounded from below in *this, in which case the infimum value and a point where expr reaches it are computed.

Parameters

expr	The linear expression to be minimized subject to `*this`;
inf_n	The numerator of the infimum value;
inf_d	The denominator of the infimum value;
minimum	`true` if and only if the infimum is also the minimum value;
g	When minimization succeeds, will be assigned a point or closure point where `expr` reaches its infimum value.

Exceptions

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

If *this is empty or expr is not bounded from below, false is returned and inf_n, inf_d, minimum and g are left untouched.

Definition at line 347 of file Polyhedron_inlines.hh.

References max_min().

                                          {
   return max_min(expr, false, inf_n, inf_d, minimum, g);
 }

bool Parma_Polyhedra_Library::Polyhedron::minimize ( ) const

private

Applies (weak) minimization to both the constraints and generators.

Returns: false if and only if *this turns out to be an empty polyhedron.

Minimization is not attempted if the Status field already declares both systems to be minimized.

Definition at line 1105 of file Polyhedron_nonpublic.cc.

Referenced by is_empty().

                               {
   // 0-dim space or empty polyhedra are already minimized.
   if (marked_empty()) {
     return false;
   }
   if (space_dim == 0) {
     return true;
   }
 
   // If the polyhedron has something pending, process it.
   if (has_something_pending()) {
     const bool not_empty = process_pending();
     PPL_ASSERT_HEAVY(OK());
     return not_empty;
   }
 
   // Here there are no pending constraints or generators.
   // Is the polyhedron already minimized?
   if (constraints_are_minimized() && generators_are_minimized()) {
     return true;
   }
 
   // If constraints or generators are up-to-date, invoking
   // update_generators() or update_constraints(), respectively,
   // minimizes both constraints and generators.
   // If both are up-to-date it does not matter whether we use
   // update_generators() or update_constraints():
   // both minimize constraints and generators.
   if (constraints_are_up_to_date()) {
     // We may discover here that `*this' is empty.
     const bool ret = update_generators();
     PPL_ASSERT_HEAVY(OK());
     return ret;
   }
   else {
     PPL_ASSERT(generators_are_up_to_date());
     update_constraints();
     PPL_ASSERT_HEAVY(OK());
     return true;
   }
 }

template<typename Source_Linear_System , typename Dest_Linear_System >

bool Parma_Polyhedra_Library::Polyhedron::minimize	(	bool	con_to_gen,
		Source_Linear_System &	source,
		Dest_Linear_System &	dest,
		Bit_Matrix &	sat
	)

staticprivate

Builds and simplifies constraints from generators (or vice versa).

Returns: true if the polyhedron is empty, false otherwise.

Parameters

con_to_gen	`true` if `source` represents the constraints, `false` otherwise;
source	The given system, which is not empty;
dest	The system to build and minimize;
sat	The saturation matrix.

dest is not const because it will be built (and then modified) during minimize(). Also, sat and source are not const because the former will be built during dest creation and the latter will maybe be sorted and modified by conversion() and simplify().

sat has the generators on its columns and the constraints on its rows if con_to_gen is true, otherwise it has the generators on its rows and the constraints on its columns.

Given source, this function builds (by means of conversion()) dest and then simplifies (invoking simplify()) source, erasing redundant rows. For the sequel we assume that source is the system of constraints and dest is the system of generators. This will simplify the description of the function; the dual case is similar.

Definition at line 71 of file Polyhedron_minimize_templates.hh.

References conversion(), Parma_Polyhedra_Library::NECESSARILY_CLOSED, Parma_Polyhedra_Library::NOT_NECESSARILY_CLOSED, OK(), Parma_Polyhedra_Library::Linear_Expression::set_space_dimension(), simplify(), and Parma_Polyhedra_Library::Bit_Matrix::transpose_assign().

                                       {
 
   typedef typename Dest_Linear_System::row_type dest_row_type;
 
   // Topologies have to agree.
   PPL_ASSERT(source.topology() == dest.topology());
   // `source' cannot be empty: even if it is an empty constraint system,
   // representing the universe polyhedron, homogenization has added
   // the positive constraint. It also cannot be an empty generator system,
   // since this function is always called starting from a non-empty
   // polyhedron.
   PPL_ASSERT(!source.has_no_rows());
 
   // Sort the source system, if necessary.
   if (!source.is_sorted()) {
     source.sort_rows();
   }
   // Initialization of the system of generators `dest'.
   // The algorithm works incrementally and we haven't seen any
   // constraint yet: as a consequence, `dest' should describe
   // the universe polyhedron of the appropriate dimension.
   // To this end, we initialize it to the identity matrix of dimension
   // `source.num_columns()': the rows represent the lines corresponding
   // to the canonical basis of the vector space.
   dimension_type dest_num_rows
     = source.topology() == NECESSARILY_CLOSED ? source.space_dimension() + 1
                                               : source.space_dimension() + 2;
 
   dest.clear();
   dest.set_space_dimension(source.space_dimension());
 
   // Initialize `dest' to the identity matrix.
   for (dimension_type i = 0; i < dest_num_rows; ++i) {
     Linear_Expression expr;
     expr.set_space_dimension(dest_num_rows - 1);
     if (i == 0) {
       expr += 1;
     }
     else {
       expr += Variable(i - 1);
     }
     dest_row_type dest_i(expr, dest_row_type::LINE_OR_EQUALITY, NECESSARILY_CLOSED);
     if (dest.topology() == NOT_NECESSARILY_CLOSED) {
       dest_i.mark_as_not_necessarily_closed();
     }
     dest.sys.insert_no_ok(dest_i, Recycle_Input());
   }
   // The identity matrix `dest' is not sorted (see the sorting rules
   // in Constrant.cc and Generator.cc).
   dest.set_sorted(false);
 
   // NOTE: the system `dest', as it is now, is not a _legal_ system of
   //       generators, because in the first row we have a line with a
   //       non-zero divisor (which should only happen for
   //       points). However, this is NOT a problem, because `source'
   //       necessarily contains the positivity constraint (or a
   //       combination of it with another constraint) which will
   //       restore things as they should be.
 
 
   // Building a saturation matrix and initializing it by setting
   // all of its elements to zero. This matrix will be modified together
   // with `dest' during the conversion.
   // NOTE: since we haven't seen any constraint yet, the relevant
   //       portion of `tmp_sat' is the sub-matrix consisting of
   //       the first 0 columns: thus the relevant portion correctly
   //       characterizes the initial saturation information.
   Bit_Matrix tmp_sat(dest_num_rows, source.num_rows());
 
   // By invoking the function conversion(), we populate `dest' with
   // the generators characterizing the polyhedron described by all
   // the constraints in `source'.
   // The `start' parameter is zero (we haven't seen any constraint yet)
   // and the 5th parameter (representing the number of lines in `dest'),
   // by construction, is equal to `dest_num_rows'.
   const dimension_type num_lines_or_equalities
     = conversion(source, 0U, dest, tmp_sat, dest_num_rows);
   // conversion() may have modified the number of rows in `dest'.
   dest_num_rows = dest.num_rows();
 
 #ifndef NDEBUG
   for (dimension_type i = dest.num_rows(); i-- > 0; ) {
     PPL_ASSERT(dest[i].OK());
   }
 #endif
 
   // Checking if the generators in `dest' represent an empty polyhedron:
   // the polyhedron is empty if there are no points
   // (because rays, lines and closure points need a supporting point).
   // Points can be detected by looking at:
   // - the divisor, for necessarily closed polyhedra;
   // - the epsilon coordinate, for NNC polyhedra.
   dimension_type first_point;
   if (dest.is_necessarily_closed()) {
     for (first_point = num_lines_or_equalities;
         first_point < dest_num_rows;
         ++first_point) {
       if (dest[first_point].expr.inhomogeneous_term() > 0) {
         break;
       }
     }
   }
   else {
     for (first_point = num_lines_or_equalities;
         first_point < dest_num_rows;
         ++first_point) {
       if (dest[first_point].expr.get(Variable(dest.space_dimension())) > 0) {
         break;
       }
     }
   }
 
   if (first_point == dest_num_rows) {
     if (con_to_gen) {
       // No point has been found: the polyhedron is empty.
       return true;
     }
     else {
       // Here `con_to_gen' is false: `dest' is a system of constraints.
       // In this case the condition `first_point == dest_num_rows'
       // actually means that all the constraints in `dest' have their
       // inhomogeneous term equal to 0.
       // This is an ILLEGAL situation, because it implies that
       // the constraint system `dest' lacks the positivity constraint
       // and no linear combination of the constraints in `dest'
       // can reintroduce the positivity constraint.
       PPL_UNREACHABLE;
       return false;
     }
   }
   else {
     // A point has been found: the polyhedron is not empty.
     // Now invoking simplify() to remove all the redundant constraints
     // from the system `source'.
     // Since the saturation matrix `tmp_sat' returned by conversion()
     // has rows indexed by generators (the rows of `dest') and columns
     // indexed by constraints (the rows of `source'), we have to
     // transpose it to obtain the saturation matrix needed by simplify().
     sat.transpose_assign(tmp_sat);
     simplify(source, sat);
     return false;
   }
 }

Congruence_System Parma_Polyhedra_Library::Polyhedron::minimized_congruences ( ) const

inline

Returns a system of (equality) congruences satisfied by *this, with no redundant congruences and having the same affine dimension as *this.

Definition at line 372 of file Polyhedron_inlines.hh.

References minimized_constraints().

                                         {
   return Congruence_System(minimized_constraints());
 }

const PPL::Constraint_System & Parma_Polyhedra_Library::Polyhedron::minimized_constraints ( ) const

Returns the system of constraints, with no redundant constraint.

Definition at line 125 of file Polyhedron_public.cc.

                                            {
   // `minimize()' or `strongly_minimize_constraints()'
   // will process any pending constraints or generators.
   if (is_necessarily_closed()) {
     minimize();
   }
   else {
     strongly_minimize_constraints();
   }
   return constraints();
 }

const PPL::Generator_System & Parma_Polyhedra_Library::Polyhedron::minimized_generators ( ) const

Returns the system of generators, with no redundant generator.

Definition at line 193 of file Polyhedron_public.cc.

Referenced by Parma_Polyhedra_Library::BHRZ03_Certificate::BHRZ03_Certificate(), and Parma_Polyhedra_Library::BHRZ03_Certificate::compare().

                                           {
   // `minimize()' or `strongly_minimize_generators()'
   // will process any pending constraints or generators.
   if (is_necessarily_closed()) {
     minimize();
   }
   else {
     strongly_minimize_generators();
   }
   // Note: calling generators() on a strongly minimized NNC generator
   // system will also ensure sortedness, which is required to correctly
   // filter away the matched closure points.
   return generators();
 }

void Parma_Polyhedra_Library::Polyhedron::modify_according_to_evolution	(	Linear_Expression &	ray,
		const Linear_Expression &	x,
		const Linear_Expression &	y
	)

staticprivate

Definition at line 602 of file Polyhedron_widenings.cc.

                                                                            {
   PPL_DIRTY_TEMP_COEFFICIENT(tmp);
   std::deque<bool> considered(x.space_dimension());
   Linear_Expression::const_iterator x_end = x.end();
   Linear_Expression::const_iterator y_end = y.end();
   Linear_Expression::const_iterator y_k = y.begin();
   for (Linear_Expression::const_iterator x_k = x.begin();
        x_k != x_end; ++x_k) {
     const Variable k_var = x_k.variable();
     const dimension_type k = k_var.id();
     if (considered[k]) {
       continue;
     }
 
     while (y_k != y_end && y_k.variable().id() < k) {
       ++y_k;
     }
 
     if (y_k == y_end) {
       break;
     }
 
     const Variable y_k_var = y_k.variable();
 
     // Note that y_k_var.id() may be greater than k.
 
     Linear_Expression::const_iterator y_h = y_k;
     // Do *not* increment y_h, since it may be after k already.
     Linear_Expression::const_iterator x_h = x_k;
     ++x_h;
     for ( ; x_h != x_end; ++x_h) {
       const dimension_type h = x_h.variable().id();
       if (considered[h]) {
         continue;
       }
 
       while (y_h != y_end && y_h.variable().id() < h) {
         ++y_h;
       }
 
       // Note that y_h may be y_end, and y_h.variable().id() may not be k.
 
       if (y_h != y_end && y_h.variable().id() == h) {
         tmp = (*x_k) * (*y_h);
       }
       else {
         tmp = 0;
       }
 
       if (y_k_var.id() == k) {
         // The following line optimizes the computation of
         // <CODE> tmp -= x[h] * y[k]; </CODE>
         Parma_Polyhedra_Library::sub_mul_assign(tmp, *x_h, *y_k);
       }
 
       const int clockwise = sgn(tmp);
       const int first_or_third_quadrant = sgn(*x_k) * sgn(*x_h);
       switch (clockwise * first_or_third_quadrant) {
       case -1:
         ray.set_coefficient(k_var, Coefficient_zero());
         considered[k] = true;
         break;
       case 1:
         ray.set_coefficient(Variable(h), Coefficient_zero());
         considered[h] = true;
         break;
       default:
         break;
       }
     }
   }
   ray.normalize();
 }

void Parma_Polyhedra_Library::Polyhedron::obtain_sorted_constraints ( ) const

private

Sorts the matrix of constraints keeping status consistency.

It is assumed that constraints are up-to-date. If at least one of the saturation matrices is up-to-date, then sat_g is kept consistent with the sorted matrix of constraints. The method is declared const because reordering the constraints does not modify the polyhedron from a logical point of view.

Definition at line 975 of file Polyhedron_nonpublic.cc.

References clear_sat_c_up_to_date(), con_sys, Parma_Polyhedra_Library::Constraint_System::is_sorted(), sat_c, sat_c_is_up_to_date(), sat_g, sat_g_is_up_to_date(), set_sat_g_up_to_date(), Parma_Polyhedra_Library::Constraint_System::sort_and_remove_with_sat(), Parma_Polyhedra_Library::Constraint_System::sort_rows(), and Parma_Polyhedra_Library::Bit_Matrix::transpose_assign().

Referenced by quick_equivalence_test().

                                                {
   PPL_ASSERT(constraints_are_up_to_date());
   // `con_sys' will be sorted up to `index_first_pending'.
   Polyhedron& x = const_cast<Polyhedron&>(*this);
   if (!x.con_sys.is_sorted()) {
     if (x.sat_g_is_up_to_date()) {
       // Sorting constraints keeping `sat_g' consistent.
       x.con_sys.sort_and_remove_with_sat(x.sat_g);
       // `sat_c' is not up-to-date anymore.
       x.clear_sat_c_up_to_date();
     }
     else if (x.sat_c_is_up_to_date()) {
       // Using `sat_c' to obtain `sat_g', then it is like previous case.
       x.sat_g.transpose_assign(x.sat_c);
       x.con_sys.sort_and_remove_with_sat(x.sat_g);
       x.set_sat_g_up_to_date();
       x.clear_sat_c_up_to_date();
     }
     else {
       // If neither `sat_g' nor `sat_c' are up-to-date,
       // we just sort the constraints.
       x.con_sys.sort_rows();
     }
   }
 
   PPL_ASSERT(con_sys.check_sorted());
 }

void Parma_Polyhedra_Library::Polyhedron::obtain_sorted_constraints_with_sat_c ( ) const

private

Sorts the matrix of constraints and updates sat_c.

It is assumed that both constraints and generators are up-to-date and minimized. The method is declared const because reordering the constraints does not modify the polyhedron from a logical point of view.

Definition at line 1033 of file Polyhedron_nonpublic.cc.

References con_sys, Parma_Polyhedra_Library::Constraint_System::is_sorted(), sat_c, sat_c_is_up_to_date(), sat_g, sat_g_is_up_to_date(), set_sat_c_up_to_date(), set_sat_g_up_to_date(), Parma_Polyhedra_Library::Constraint_System::set_sorted(), Parma_Polyhedra_Library::Constraint_System::sort_and_remove_with_sat(), Parma_Polyhedra_Library::Bit_Matrix::transpose_assign(), and update_sat_c().

Referenced by process_pending_constraints().

                                                           {
   PPL_ASSERT(constraints_are_up_to_date());
   PPL_ASSERT(constraints_are_minimized());
   // `con_sys' will be sorted up to `index_first_pending'.
   Polyhedron& x = const_cast<Polyhedron&>(*this);
   // At least one of the saturation matrices must be up-to-date.
   if (!x.sat_c_is_up_to_date() && !x.sat_g_is_up_to_date()) {
     x.update_sat_c();
   }
   if (x.con_sys.is_sorted()) {
     if (x.sat_c_is_up_to_date()) {
       // If constraints are already sorted and sat_c is up to
       // date there is nothing to do.
       return;
     }
   }
   else {
     if (!x.sat_g_is_up_to_date()) {
       // If constraints are not sorted and sat_g is not up-to-date
       // we obtain sat_g from sat_c (that has to be up-to-date)...
       x.sat_g.transpose_assign(x.sat_c);
       x.set_sat_g_up_to_date();
     }
     // ... and sort it together with constraints.
     x.con_sys.sort_and_remove_with_sat(x.sat_g);
   }
   // Obtaining sat_c from sat_g.
   x.sat_c.transpose_assign(x.sat_g);
   x.set_sat_c_up_to_date();
   // Constraints are sorted now.
   x.con_sys.set_sorted(true);
 
   PPL_ASSERT(con_sys.check_sorted());
 }

void Parma_Polyhedra_Library::Polyhedron::obtain_sorted_generators ( ) const

private

Sorts the matrix of generators keeping status consistency.

It is assumed that generators are up-to-date. If at least one of the saturation matrices is up-to-date, then sat_c is kept consistent with the sorted matrix of generators. The method is declared const because reordering the generators does not modify the polyhedron from a logical point of view.

Definition at line 1004 of file Polyhedron_nonpublic.cc.

References clear_sat_g_up_to_date(), gen_sys, Parma_Polyhedra_Library::Generator_System::is_sorted(), sat_c, sat_c_is_up_to_date(), sat_g, sat_g_is_up_to_date(), set_sat_c_up_to_date(), Parma_Polyhedra_Library::Generator_System::sort_and_remove_with_sat(), Parma_Polyhedra_Library::Generator_System::sort_rows(), and Parma_Polyhedra_Library::Bit_Matrix::transpose_assign().

Referenced by quick_equivalence_test().

                                               {
   PPL_ASSERT(generators_are_up_to_date());
   // `gen_sys' will be sorted up to `index_first_pending'.
   Polyhedron& x = const_cast<Polyhedron&>(*this);
   if (!x.gen_sys.is_sorted()) {
     if (x.sat_c_is_up_to_date()) {
       // Sorting generators keeping 'sat_c' consistent.
       x.gen_sys.sort_and_remove_with_sat(x.sat_c);
       // `sat_g' is not up-to-date anymore.
       x.clear_sat_g_up_to_date();
     }
     else if (x.sat_g_is_up_to_date()) {
       // Obtaining `sat_c' from `sat_g' and proceeding like previous case.
       x.sat_c.transpose_assign(x.sat_g);
       x.gen_sys.sort_and_remove_with_sat(x.sat_c);
       x.set_sat_c_up_to_date();
       x.clear_sat_g_up_to_date();
     }
     else {
       // If neither `sat_g' nor `sat_c' are up-to-date, we just sort
       // the generators.
       x.gen_sys.sort_rows();
     }
   }
 
   PPL_ASSERT(gen_sys.check_sorted());
 }

void Parma_Polyhedra_Library::Polyhedron::obtain_sorted_generators_with_sat_g ( ) const

private

Sorts the matrix of generators and updates sat_g.

It is assumed that both constraints and generators are up-to-date and minimized. The method is declared const because reordering the generators does not modify the polyhedron from a logical point of view.

Definition at line 1069 of file Polyhedron_nonpublic.cc.

References gen_sys, Parma_Polyhedra_Library::Generator_System::is_sorted(), sat_c, sat_c_is_up_to_date(), sat_g, sat_g_is_up_to_date(), set_sat_c_up_to_date(), set_sat_g_up_to_date(), Parma_Polyhedra_Library::Generator_System::set_sorted(), Parma_Polyhedra_Library::Generator_System::sort_and_remove_with_sat(), Parma_Polyhedra_Library::Bit_Matrix::transpose_assign(), and update_sat_g().

Referenced by process_pending_generators().

                                                          {
   PPL_ASSERT(generators_are_up_to_date());
   // `gen_sys' will be sorted up to `index_first_pending'.
   Polyhedron& x = const_cast<Polyhedron&>(*this);
   // At least one of the saturation matrices must be up-to-date.
   if (!x.sat_c_is_up_to_date() && !x.sat_g_is_up_to_date()) {
     x.update_sat_g();
   }
 
   if (x.gen_sys.is_sorted()) {
     if (x.sat_g_is_up_to_date()) {
       // If generators are already sorted and sat_g is up to
       // date there is nothing to do.
       return;
     }
   }
   else {
     if (!x.sat_c_is_up_to_date()) {
       // If generators are not sorted and sat_c is not up-to-date
       // we obtain sat_c from sat_g (that has to be up-to-date)...
       x.sat_c.transpose_assign(x.sat_g);
       x.set_sat_c_up_to_date();
     }
     // ... and sort it together with generators.
     x.gen_sys.sort_and_remove_with_sat(x.sat_c);
   }
   // Obtaining sat_g from sat_c.
   x.sat_g.transpose_assign(sat_c);
   x.set_sat_g_up_to_date();
   // Generators are sorted now.
   x.gen_sys.set_sorted(true);
 
   PPL_ASSERT(gen_sys.check_sorted());
 }

bool Parma_Polyhedra_Library::Polyhedron::OK ( bool check_not_empty = false ) const

Checks if all the invariants are satisfied.

Returns: true if and only if *this satisfies all the invariants and either check_not_empty is false or *this is not empty.

Parameters

check_not_empty true if and only if, in addition to checking the invariants, *this must be checked to be not empty.

The check is performed so as to intrude as little as possible. If the library has been compiled with run-time assertions enabled, error messages are written on std::cerr in case invariants are violated. This is useful for the purpose of debugging the library.

Definition at line 832 of file Polyhedron_public.cc.

Referenced by add_space_dimensions_and_embed(), BHRZ03_combining_constraints(), BHRZ03_evolving_points(), BHRZ03_evolving_rays(), BHRZ03_widening_assign(), Parma_Polyhedra_Library::C_Polyhedron::C_Polyhedron(), H79_widening_assign(), intersection_assign(), is_included_in(), map_space_dimensions(), minimize(), Parma_Polyhedra_Library::NNC_Polyhedron::NNC_Polyhedron(), poly_hull_assign(), Polyhedron(), positive_time_elapse_assign_impl(), simplify_using_context_assign(), and time_elapse_assign().

                                             {
 #ifndef NDEBUG
   using std::endl;
   using std::cerr;
 #endif
 
   // Check whether the topologies of `con_sys' and `gen_sys' agree.
   if (con_sys.topology() != gen_sys.topology()) {
 #ifndef NDEBUG
     cerr << "Constraints and generators have different topologies!"
          << endl;
 #endif
     goto bomb;
   }
 
   // Check whether the status information is legal.
   if (!status.OK()) {
     goto bomb;
   }
 
   if (marked_empty()) {
     if (check_not_empty) {
       // The caller does not want the polyhedron to be empty.
 #ifndef NDEBUG
       cerr << "Empty polyhedron!" << endl;
 #endif
       goto bomb;
     }
 
     // An empty polyhedron is allowed if the system of constraints
     // either has no rows or only contains an unsatisfiable constraint
     // and if it has no pending constraints or generators.
     if (has_something_pending()) {
 #ifndef NDEBUG
       cerr << "The polyhedron is empty, "
            << "but it has something pending" << endl;
 #endif
       goto bomb;
     }
     if (con_sys.has_no_rows()) {
       return true;
     }
     else {
       if (con_sys.space_dimension() != space_dim) {
 #ifndef NDEBUG
         cerr << "The polyhedron is in a space of dimension "
              << space_dim
              << " while the system of constraints is in a space of dimension "
              << con_sys.space_dimension()
              << endl;
 #endif
         goto bomb;
       }
       if (con_sys.num_rows() != 1) {
 #ifndef NDEBUG
         cerr << "The system of constraints for an empty polyhedron "
              << "has more then one row"
              << endl;
 #endif
         goto bomb;
       }
       if (!con_sys[0].is_inconsistent()) {
 #ifndef NDEBUG
         cerr << "Empty polyhedron with a satisfiable system of constraints"
              << endl;
 #endif
         goto bomb;
       }
       // Here we have only one, inconsistent constraint.
       return true;
     }
   }
 
   // A zero-dimensional, non-empty polyhedron is legal only if the
   // system of constraint `con_sys' and the system of generators
   // `gen_sys' have no rows.
   if (space_dim == 0) {
     if (has_something_pending()) {
 #ifndef NDEBUG
       cerr << "Zero-dimensional polyhedron with something pending"
            << endl;
 #endif
       goto bomb;
     }
     if (!con_sys.has_no_rows() || !gen_sys.has_no_rows()) {
 #ifndef NDEBUG
       cerr << "Zero-dimensional polyhedron with a non-empty"
            << endl
            << "system of constraints or generators."
            << endl;
 #endif
       goto bomb;
     }
     return true;
   }
 
   // A polyhedron is defined by a system of constraints
   // or a system of generators: at least one of them must be up to date.
   if (!constraints_are_up_to_date() && !generators_are_up_to_date()) {
 #ifndef NDEBUG
     cerr << "Polyhedron not empty, not zero-dimensional"
          << endl
          << "and with neither constraints nor generators up-to-date!"
          << endl;
 #endif
     goto bomb;
   }
 
   // Here we check if the size of the matrices is consistent.
   // Let us suppose that all the matrices are up-to-date; this means:
   // `con_sys' : number of constraints x poly_num_columns
   // `gen_sys' : number of generators  x poly_num_columns
   // `sat_c'   : number of generators  x number of constraints
   // `sat_g'   : number of constraints x number of generators.
   if (constraints_are_up_to_date()) {
     if (con_sys.space_dimension() != space_dim) {
 #ifndef NDEBUG
       cerr << "Incompatible size! (con_sys and space_dim)"
            << endl;
 #endif
       goto bomb;
     }
     if (sat_c_is_up_to_date()) {
       if (con_sys.first_pending_row() != sat_c.num_columns()) {
 #ifndef NDEBUG
         cerr << "Incompatible size! (con_sys and sat_c)"
              << endl;
 #endif
         goto bomb;
       }
     }
     if (sat_g_is_up_to_date()) {
       if (con_sys.first_pending_row() != sat_g.num_rows()) {
 #ifndef NDEBUG
         cerr << "Incompatible size! (con_sys and sat_g)"
              << endl;
 #endif
         goto bomb;
       }
     }
     if (generators_are_up_to_date()) {
       if (con_sys.space_dimension() != gen_sys.space_dimension()) {
 #ifndef NDEBUG
         cerr << "Incompatible size! (con_sys and gen_sys)"
              << endl;
 #endif
         goto bomb;
       }
     }
   }
 
   if (generators_are_up_to_date()) {
     if (gen_sys.space_dimension() != space_dim) {
 #ifndef NDEBUG
       cerr << "Incompatible size! (gen_sys and space_dim)"
            << endl;
 #endif
       goto bomb;
     }
     if (sat_c_is_up_to_date()) {
       if (gen_sys.first_pending_row() != sat_c.num_rows()) {
 #ifndef NDEBUG
         cerr << "Incompatible size! (gen_sys and sat_c)"
              << endl;
 #endif
         goto bomb;
       }
     }
     if (sat_g_is_up_to_date()) {
       if (gen_sys.first_pending_row() != sat_g.num_columns()) {
 #ifndef NDEBUG
         cerr << "Incompatible size! (gen_sys and sat_g)"
              << endl;
 #endif
         goto bomb;
       }
     }
     if (gen_sys.first_pending_row() == 0) {
 #ifndef NDEBUG
       cerr << "Up-to-date generator system with all rows pending!"
            << endl;
 #endif
       goto bomb;
     }
 
     // A non-empty system of generators describing a polyhedron
     // is valid if and only if it contains a point.
     if (!gen_sys.has_no_rows() && !gen_sys.has_points()) {
 #ifndef NDEBUG
       cerr << "Non-empty generator system declared up-to-date "
            << "has no points!"
            << endl;
 #endif
       goto bomb;
     }
 
 #if 0 // To be activated when Status keeps strong minimization flags.
     //=================================================
     // TODO: this test is wrong in the general case.
     // However, such an invariant does hold for a
     // strongly-minimized Generator_System.
     // We will activate this test as soon as the Status
     // flags will be able to remember if a system is
     // strongly minimized.
 
     // Checking that the number of closure points is always
     // greater than the number of points.
     if (!is_necessarily_closed()) {
       dimension_type num_points = 0;
       dimension_type num_closure_points = 0;
       dimension_type eps_index = gen_sys.space_dimension() + 1;
       for (dimension_type i = gen_sys.num_rows(); i-- > 0; ) {
         if (!gen_sys[i].is_line_or_ray()) {
           if (gen_sys[i][eps_index] > 0) {
             ++num_points;
           }
           else {
             ++num_closure_points;
           }
         }
       }
       if (num_points > num_closure_points) {
 #ifndef NDEBUG
         cerr << "# POINTS > # CLOSURE_POINTS" << endl;
 #endif
         goto bomb;
       }
     }
     //=================================================
 #endif
 
     if (generators_are_minimized()) {
       // If the system of generators is minimized, the number of
       // lines, rays and points of the polyhedron must be the same as
       // of a temporary, minimized one. If this does not happen then
       // the polyhedron is not OK.
       Constraint_System new_con_sys(topology(), default_con_sys_repr);
       Generator_System gs_without_pending = gen_sys;
       gs_without_pending.remove_trailing_rows(gs_without_pending.num_rows()
                                               - gen_sys.first_pending_row());
       gs_without_pending.unset_pending_rows();
       Generator_System copy_of_gen_sys = gs_without_pending;
       Bit_Matrix new_sat_c;
       minimize(false, copy_of_gen_sys, new_con_sys, new_sat_c);
       const dimension_type copy_num_lines = copy_of_gen_sys.num_lines();
       if (gs_without_pending.num_rows() != copy_of_gen_sys.num_rows()
           || gs_without_pending.num_lines() != copy_num_lines
           || gs_without_pending.num_rays() != copy_of_gen_sys.num_rays()) {
 #ifndef NDEBUG
         cerr << "Generators are declared minimized, but they are not!\n"
              << "Here is the minimized form of the generators:\n";
         copy_of_gen_sys.ascii_dump(cerr);
         cerr << endl;
 #endif
         goto bomb;
       }
 
       // CHECKME : the following observation is not formally true
       //           for a NNC_Polyhedron. But it may be true for its
       //           representation ...
 
       // If the corresponding polyhedral cone is _pointed_, then
       // a minimal system of generators is unique up to positive scaling.
       // We thus verify if the cone is pointed (i.e., there are no lines)
       // and, after normalizing and sorting a copy of the system `gen_sys'
       // of the polyhedron (we use a copy not to modify the polyhedron's
       // system) and the system `copy_of_gen_sys' that has been just
       // minimized, we check if the two matrices are identical.  If
       // they are different it means that the generators of the
       // polyhedron are declared minimized, but they are not.
       if (copy_num_lines == 0) {
         copy_of_gen_sys.strong_normalize();
         copy_of_gen_sys.sort_rows();
         gs_without_pending.strong_normalize();
         gs_without_pending.sort_rows();
         if (copy_of_gen_sys != gs_without_pending) {
 #ifndef NDEBUG
           cerr << "Generators are declared minimized, but they are not!\n"
                << "(we are in the case:\n"
                << "dimension of lineality space equal to 0)\n"
                << "Here is the minimized form of the generators:\n";
           copy_of_gen_sys.ascii_dump(cerr);
           cerr << endl;
 #endif
             goto bomb;
         }
       }
     }
   }
 
   if (constraints_are_up_to_date()) {
     if (con_sys.first_pending_row() == 0) {
 #ifndef NDEBUG
       cerr << "Up-to-date constraint system with all rows pending!"
            << endl;
 #endif
       goto bomb;
     }
 
     // A non-empty system of constraints describing a polyhedron
     // must contain a constraint with a non-zero inhomogeneous term;
     // such a constraint corresponds to (a combination of other
     // constraints with):
     // -* the positivity constraint, for necessarily closed polyhedra;
     // -* the epsilon <= 1 constraint, for NNC polyhedra.
     bool no_positivity_constraint = true;
     for (dimension_type i = con_sys.num_rows(); i-- > 0; ) {
       if (con_sys[i].inhomogeneous_term() != 0) {
         no_positivity_constraint = false;
         break;
       }
     }
     if (no_positivity_constraint) {
 #ifndef NDEBUG
       cerr << "Non-empty constraint system has no positivity constraint"
            << endl;
 #endif
       goto bomb;
     }
 
     if (!is_necessarily_closed()) {
       // A non-empty system of constraints describing a NNC polyhedron
       // must also contain a (combination of) the constraint epsilon >= 0,
       // i.e., a constraint with a positive epsilon coefficient.
       bool no_epsilon_geq_zero = true;
       for (dimension_type i = con_sys.num_rows(); i-- > 0; ) {
         if (con_sys[i].epsilon_coefficient() > 0) {
           no_epsilon_geq_zero = false;
           break;
         }
       }
       if (no_epsilon_geq_zero) {
 #ifndef NDEBUG
         cerr << "Non-empty constraint system for NNC polyhedron "
              << "has no epsilon >= 0 constraint"
              << endl;
 #endif
         goto bomb;
       }
     }
 
     Constraint_System cs_without_pending = con_sys;
     cs_without_pending.remove_trailing_rows(cs_without_pending.num_rows()
                                             - con_sys.first_pending_row());
     cs_without_pending.unset_pending_rows();
     Constraint_System copy_of_con_sys = cs_without_pending;
     bool empty = false;
     if (check_not_empty || constraints_are_minimized()) {
       Generator_System new_gen_sys(topology(), default_gen_sys_repr);
       Bit_Matrix new_sat_g;
       empty = minimize(true, copy_of_con_sys, new_gen_sys, new_sat_g);
     }
 
     if (empty && check_not_empty) {
 #ifndef NDEBUG
       cerr << "Unsatisfiable system of constraints!"
            << endl;
 #endif
       goto bomb;
     }
 
     if (constraints_are_minimized()) {
       // If the constraints are minimized, the number of equalities
       // and of inequalities of the system of the polyhedron must be
       // the same of the temporary minimized one.
       // If it does not happen, the polyhedron is not OK.
       if (cs_without_pending.num_rows() != copy_of_con_sys.num_rows()
           || cs_without_pending.num_equalities()
           != copy_of_con_sys.num_equalities()) {
 #ifndef NDEBUG
         cerr << "Constraints are declared minimized, but they are not!\n"
              << "Here is the minimized form of the constraints:\n";
         copy_of_con_sys.ascii_dump(cerr);
         cerr << endl;
 #endif
         goto bomb;
       }
       // The system `copy_of_con_sys' has the form that is obtained
       // after applying methods gauss() and back_substitute().
       // A system of constraints can be minimal even if it does not
       // have this form. So, to verify if the polyhedron is correct,
       // we copy the system `con_sys' in a temporary one and then
       // modify it using method simplify() (which calls both gauss()
       // and back_substitute()).
       // If the temporary system and `copy_of_con_sys' are different,
       // the polyhedron is not OK.
       copy_of_con_sys.strong_normalize();
       copy_of_con_sys.sort_rows();
       cs_without_pending.simplify();
       cs_without_pending.strong_normalize();
       cs_without_pending.sort_rows();
       if (cs_without_pending != copy_of_con_sys) {
 #ifndef NDEBUG
         cerr << "Constraints are declared minimized, but they are not!\n"
              << "Here is the minimized form of the constraints:\n";
         copy_of_con_sys.ascii_dump(cerr);
         cerr << endl;
 #endif
         goto bomb;
       }
     }
   }
 
   if (sat_c_is_up_to_date()) {
     for (dimension_type i = sat_c.num_rows(); i-- > 0; ) {
       const Generator tmp_gen = gen_sys[i];
       const Bit_Row tmp_sat = sat_c[i];
       for (dimension_type j = sat_c.num_columns(); j-- > 0; ) {
         const bool sat_j = (Scalar_Products::sign(con_sys[j], tmp_gen) == 0);
         if (sat_j == tmp_sat[j]) {
 #ifndef NDEBUG
           cerr << "sat_c is declared up-to-date, but it is not!"
                << endl;
 #endif
           goto bomb;
         }
       }
     }
   }
   if (sat_g_is_up_to_date()) {
     for (dimension_type i = sat_g.num_rows(); i-- > 0; ) {
       const Constraint tmp_con = con_sys[i];
       const Bit_Row tmp_sat = sat_g[i];
       for (dimension_type j = sat_g.num_columns(); j-- > 0; ) {
         const bool sat_j = (Scalar_Products::sign(tmp_con, gen_sys[j]) == 0);
         if (sat_j == tmp_sat[j]) {
 #ifndef NDEBUG
           cerr << "sat_g is declared up-to-date, but it is not!"
                << endl;
 #endif
           goto bomb;
         }
       }
     }
   }
   if (has_pending_constraints()) {
     if (con_sys.num_pending_rows() == 0) {
 #ifndef NDEBUG
       cerr << "The polyhedron is declared to have pending constraints, "
            << "but con_sys has no pending rows!"
            << endl;
 #endif
       goto bomb;
     }
   }
 
   if (has_pending_generators()) {
     if (gen_sys.num_pending_rows() == 0) {
 #ifndef NDEBUG
       cerr << "The polyhedron is declared to have pending generators, "
            << "but gen_sys has no pending rows!"
            << endl;
 #endif
       goto bomb;
     }
   }
 
   return true;
 
  bomb:
 #ifndef NDEBUG
   cerr << "Here is the guilty polyhedron:"
        << endl;
   ascii_dump(cerr);
 #endif
   return false;
 }

PPL::Polyhedron & Parma_Polyhedra_Library::Polyhedron::operator= ( const Polyhedron & y )

protected

The assignment operator. (*this and y can be dimension-incompatible.)

Definition at line 327 of file Polyhedron_nonpublic.cc.

References con_sys, constraints_are_up_to_date(), gen_sys, generators_are_up_to_date(), marked_empty(), sat_c, sat_c_is_up_to_date(), sat_g, sat_g_is_up_to_date(), space_dim, status, and topology().

Referenced by Parma_Polyhedra_Library::NNC_Polyhedron::operator=(), and Parma_Polyhedra_Library::C_Polyhedron::operator=().

                                             {
   // Being a protected method, we simply assert that topologies do match.
   PPL_ASSERT(topology() == y.topology());
   space_dim = y.space_dim;
   if (y.marked_empty()) {
     set_empty();
   }
   else if (space_dim == 0) {
     set_zero_dim_univ();
   }
   else {
     status = y.status;
     if (y.constraints_are_up_to_date()) {
       con_sys.assign_with_pending(y.con_sys);
     }
     if (y.generators_are_up_to_date()) {
       gen_sys.assign_with_pending(y.gen_sys);
     }
     if (y.sat_c_is_up_to_date()) {
       sat_c = y.sat_c;
     }
     if (y.sat_g_is_up_to_date()) {
       sat_g = y.sat_g;
     }
   }
   return *this;
 }

template<typename FP_Format , typename Interval_Info >

void Parma_Polyhedra_Library::Polyhedron::overapproximate_linear_form	(	const Linear_Form< Interval< FP_Format, Interval_Info > > &	lf,
		const dimension_type	lf_dimension,
		Linear_Form< Interval< FP_Format, Interval_Info > > &	result
	)

protected

Helper function that overapproximates an interval linear form.

Parameters

lf	The linear form on intervals with floating point boundaries to approximate. ALL of its coefficients MUST be bounded.
lf_dimension	Must be the space dimension of `lf`.
result	Used to store the result.

This function makes result become a linear form that is a correct approximation of lf under the constraints specified by *this. The resulting linear form has the property that all of its variable coefficients have a non-significant upper bound and can thus be considered as singletons.

Definition at line 431 of file Polyhedron_templates.hh.

References Parma_Polyhedra_Library::Box< ITV >::get_interval(), and PPL_COMPILE_TIME_CHECK.

Referenced by affine_form_image(), and refine_with_linear_form_inequality().

                                                                                          {
 
   // Check that FP_Format is indeed a floating point type.
   PPL_COMPILE_TIME_CHECK(!std::numeric_limits<FP_Format>::is_exact,
                          "Polyhedron::overapproximate_linear_form:"
                          " FP_Format not a floating point type.");
 
   typedef Interval<FP_Format, Interval_Info> FP_Interval_Type;
   typedef Linear_Form<FP_Interval_Type> FP_Linear_Form;
 
   // Build a Box from the Polyhedron so that we can extract upper and
   // lower bounds of variables easily.
   Box<FP_Interval_Type> box(*this);
 
   result = FP_Linear_Form(lf.inhomogeneous_term());
   // FIXME: this may not be policy-neutral.
   const FP_Interval_Type aux_divisor1(static_cast<FP_Format>(0.5));
   FP_Interval_Type aux_divisor2(aux_divisor1);
   aux_divisor2.lower() = static_cast<FP_Format>(-0.5);
 
   for (dimension_type i = 0; i < lf_dimension; ++i) {
     Variable curr_var(i);
     const FP_Interval_Type& curr_coeff = lf.coefficient(curr_var);
     PPL_ASSERT(curr_coeff.is_bounded());
     FP_Format curr_lb = curr_coeff.lower();
     FP_Format curr_ub = curr_coeff.upper();
     if (curr_lb != 0 || curr_ub != 0) {
       const FP_Interval_Type& curr_int = box.get_interval(curr_var);
       FP_Interval_Type curr_addend(curr_ub - curr_lb);
       curr_addend *= aux_divisor2;
       curr_addend *= curr_int;
       result += curr_addend;
       curr_addend = FP_Interval_Type(curr_lb + curr_ub);
       curr_addend *= aux_divisor1;
       FP_Linear_Form curr_addend_lf(curr_var);
       curr_addend_lf *= curr_addend;
       result += curr_addend_lf;
     }
   }
 }

void Parma_Polyhedra_Library::Polyhedron::poly_difference_assign ( const Polyhedron & y )

Assigns to *this the poly-difference of *this and y.

Exceptions

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

Definition at line 2648 of file Polyhedron_public.cc.

Referenced by difference_assign().

                                                          {
   Polyhedron& x = *this;
   // Topology compatibility check.
   if (x.topology() != y.topology()) {
     throw_topology_incompatible("poly_difference_assign(y)", "y", y);
   // Dimension-compatibility check.
   }
   if (x.space_dim != y.space_dim) {
     throw_dimension_incompatible("poly_difference_assign(y)", "y", y);
   }
 
   // The difference of a polyhedron `p' and an empty polyhedron is `p'.
   if (y.marked_empty()) {
     return;
   }
   // The difference of an empty polyhedron and of a polyhedron `p' is empty.
   if (x.marked_empty()) {
     return;
   }
 
   // If both polyhedra are zero-dimensional,
   // then at this point they are necessarily universe polyhedra,
   // so that their difference is empty.
   if (x.space_dim == 0) {
     x.set_empty();
     return;
   }
 
   // TODO: This is just an executable specification.
   //       Have to find a more efficient method.
 
   if (y.contains(x)) {
     x.set_empty();
     return;
   }
 
   // Being lazy here is only harmful.
   // `minimize()' will process any pending constraints or generators.
   if (!y.minimize()) {
     return;
   }
   x.minimize();
 
   Polyhedron new_polyhedron(topology(), x.space_dim, EMPTY);
 
   const Constraint_System& y_cs = y.constraints();
   for (Constraint_System::const_iterator i = y_cs.begin(),
          y_cs_end = y_cs.end(); i != y_cs_end; ++i) {
     const Constraint& c = *i;
     PPL_ASSERT(!c.is_tautological());
     PPL_ASSERT(!c.is_inconsistent());
     // If the polyhedron `x' is included in the polyhedron defined by
     // `c', then `c' can be skipped, as adding its complement to `x'
     // would result in the empty polyhedron.  Moreover, if we operate
     // on C-polyhedra and `c' is a non-strict inequality, c _must_ be
     // skipped for otherwise we would obtain a result that is less
     // precise than the poly-difference.
     if (x.relation_with(c).implies(Poly_Con_Relation::is_included())) {
       continue;
     }
     Polyhedron z = x;
     const Linear_Expression e(c.expression());
     switch (c.type()) {
     case Constraint::NONSTRICT_INEQUALITY:
       if (is_necessarily_closed()) {
         z.refine_no_check(e <= 0);
       }
       else {
         z.refine_no_check(e < 0);
       }
       break;
     case Constraint::STRICT_INEQUALITY:
       z.refine_no_check(e <= 0);
       break;
     case Constraint::EQUALITY:
       if (is_necessarily_closed()) {
         // We have already filtered out the case
         // when `x' is included in `y': the result is `x'.
         return;
       }
       else {
         Polyhedron w = x;
         w.refine_no_check(e < 0);
         new_polyhedron.poly_hull_assign(w);
         z.refine_no_check(e > 0);
       }
       break;
     }
     new_polyhedron.poly_hull_assign(z);
   }
   *this = new_polyhedron;
 
   PPL_ASSERT_HEAVY(OK());
 }

void Parma_Polyhedra_Library::Polyhedron::poly_hull_assign ( const Polyhedron & y )

Assigns to *this the poly-hull of *this and y.

Exceptions

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

Definition at line 2576 of file Polyhedron_public.cc.

References can_have_something_pending(), clear_constraints_up_to_date(), clear_generators_minimized(), gen_sys, generators_are_up_to_date(), has_pending_constraints(), has_pending_generators(), Parma_Polyhedra_Library::Generator_System::insert(), Parma_Polyhedra_Library::Generator_System::insert_pending(), Parma_Polyhedra_Library::Generator_System::is_sorted(), marked_empty(), Parma_Polyhedra_Library::Generator_System::merge_rows_assign(), OK(), process_pending_constraints(), set_generators_pending(), space_dim, topology(), and update_generators().

Referenced by Parma_Polyhedra_Library::Pointset_Powerset< PSET >::affine_dimension(), poly_difference_assign(), and upper_bound_assign().

                                                    {
   Polyhedron& x = *this;
   // Topology compatibility check.
   if (x.topology() != y.topology()) {
     throw_topology_incompatible("poly_hull_assign(y)", "y", y);
   }
   // Dimension-compatibility check.
   if (x.space_dim != y.space_dim) {
     throw_dimension_incompatible("poly_hull_assign(y)", "y", y);
   }
 
   // The poly-hull of a polyhedron `p' with an empty polyhedron is `p'.
   if (y.marked_empty()) {
     return;
   }
   if (x.marked_empty()) {
     x = y;
     return;
   }
 
   // If both polyhedra are zero-dimensional,
   // then at this point they are necessarily universe polyhedra,
   // so that their poly-hull is the universe polyhedron too.
   if (x.space_dim == 0) {
     return;
   }
 
   // Both systems of generators have to be up-to-date,
   // possibly having pending generators.
   if ((x.has_pending_constraints() && !x.process_pending_constraints())
       || (!x.generators_are_up_to_date() && !x.update_generators())) {
     // Discovered `x' empty when updating generators.
     x = y;
     return;
   }
   if ((y.has_pending_constraints() && !y.process_pending_constraints())
       || (!y.generators_are_up_to_date() && !y.update_generators())) {
     // Discovered `y' empty when updating generators.
     return;
   }
   // Here both systems are up-to-date and possibly have pending generators
   // (but they cannot have pending constraints).
   PPL_ASSERT(!x.has_pending_constraints() && x.generators_are_up_to_date());
   PPL_ASSERT(!y.has_pending_constraints() && y.generators_are_up_to_date());
 
   // If `x' can support pending generators,
   // the generators of `y' are added as pending generators of `x'.
   if (x.can_have_something_pending()) {
     x.gen_sys.insert_pending(y.gen_sys);
     x.set_generators_pending();
   }
   else {
     // `x' cannot support pending generators.
     // If both generator systems are (fully) sorted, then we can merge
     // them; otherwise we simply add the second to the first.
     if (x.gen_sys.is_sorted()
         && y.gen_sys.is_sorted() && !y.has_pending_generators()) {
       x.gen_sys.merge_rows_assign(y.gen_sys);
     }
     else {
       x.gen_sys.insert(y.gen_sys);
     }
     // Constraints are no longer up-to-date
     // and generators are no longer minimized.
     x.clear_constraints_up_to_date();
     x.clear_generators_minimized();
   }
   // At this point both `x' and `y' are not empty.
   PPL_ASSERT_HEAVY(x.OK(true) && y.OK(true));
 }

void Parma_Polyhedra_Library::Polyhedron::positive_time_elapse_assign ( const Polyhedron & y )

Assigns to *this (the best approximation of) the result of computing the positive time-elapse between *this and y.

Exceptions

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

void Parma_Polyhedra_Library::Polyhedron::positive_time_elapse_assign_impl ( const Polyhedron & y )

protected

Assuming *this is NNC, assigns to *this the result of the "positive time-elapse" between *this and y.

Exceptions

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

Definition at line 2375 of file Polyhedron_nonpublic.cc.

Referenced by Parma_Polyhedra_Library::NNC_Polyhedron::positive_time_elapse_assign().

                                                                    {
   // Private method: the caller must ensure the following.
   PPL_ASSERT(!is_necessarily_closed());
 
   Polyhedron& x = *this;
   // Dimension-compatibility checks.
   if (x.space_dim != y.space_dim) {
     throw_dimension_incompatible("positive_time_elapse_assign(y)", "y", y);
   }
 
   // Dealing with the zero-dimensional case.
   if (x.space_dim == 0) {
     if (y.marked_empty()) {
       x.set_empty();
     }
     return;
   }
 
   // If either one of `x' or `y' is empty, the result is empty too.
   if (x.marked_empty() || y.marked_empty()
       || (x.has_pending_constraints() && !x.process_pending_constraints())
       || (!x.generators_are_up_to_date() && !x.update_generators())
       || (y.has_pending_constraints() && !y.process_pending_constraints())
       || (!y.generators_are_up_to_date() && !y.update_generators())) {
     x.set_empty();
     return;
   }
 
   // At this point both generator systems are up-to-date,
   // possibly containing pending generators.
 
   // The new system of generators that will replace the one of x.
   Generator_System new_gs(x.gen_sys);
   dimension_type num_rows = new_gs.num_rows();
 
   // We are going to do all sorts of funny things with new_gs, so we better
   // mark it unsorted.
   // Note: `sorted' is an attribute of Linear_System, encapsulated by
   // Generator_System; hence, the following is equivalent to
   // new_gs.set_sorted(false).
   new_gs.sys.set_sorted(false);
 
   // Remove all points from new_gs and put them in 'x_points_gs' for later use.
   // Notice that we do not remove the corresponding closure points.
   Generator_System x_points_gs;
   for (dimension_type i = num_rows; i-- > 0;) {
     Generator &g = new_gs.sys.rows[i];
     if (g.is_point()) {
       x_points_gs.insert(g);
       --num_rows;
       swap(g, new_gs.sys.rows[num_rows]);
     }
   }
   new_gs.sys.rows.resize(num_rows);
 
   // When there are no pending rows, the pending row index points at
   // the smallest non-valid row, i.e., it is equal to the number of rows.
   // Hence, each time the system is manually resized, the pending row index
   // must be updated.
   new_gs.unset_pending_rows();
   PPL_ASSERT(new_gs.sys.OK());
 
   // We use a pointer in order to avoid copying the generator
   // system when it is not necessary, i.e., when y is an NNC.
   const Generator_System *gs = &y.gen_sys;
   Generator_System y_gs;
 
   // If y is closed, promote its generator system to not necessarily closed.
   if (y.is_necessarily_closed()) {
     y_gs = y.gen_sys;
     y_gs.convert_into_non_necessarily_closed();
     y_gs.add_corresponding_closure_points();
     gs = &y_gs;
   }
 
   PPL_ASSERT(gs->OK());
 
   const dimension_type gs_num_rows = gs->num_rows();
 
   // For each generator g of y...
   for (dimension_type i = gs_num_rows; i-- > 0; ) {
     const Generator &g = gs->sys.rows[i];
 
     switch (g.type()) {
     case Generator::POINT:
       // In principle, points should be added to new_gs as rays.
       // However, for each point there is a corresponding closure point in "gs".
       // Hence, we leave this operation to closure points.
 
       // Insert into new_gs the sum of g and each point of x.
       // For each original point gx of x...
       for (dimension_type j = x_points_gs.sys.num_rows(); j-- > 0; ) {
         const Generator &gx = x_points_gs.sys.rows[j];
         PPL_ASSERT(gx.is_point());
         // ...insert the point obtained as the sum of g and gx.
         Generator new_g = g; // make a copy
         Coefficient new_divisor = g.expr.inhomogeneous_term() * gx.expr.inhomogeneous_term();
 
         new_g.expr.linear_combine(gx.expr, gx.expr.inhomogeneous_term(), g.expr.inhomogeneous_term());
         new_g.expr.set_inhomogeneous_term(new_divisor);
         if (new_g.is_not_necessarily_closed()) {
           new_g.set_epsilon_coefficient(g.epsilon_coefficient());
         }
         new_g.expr.normalize();
         PPL_ASSERT(new_g.OK());
         new_gs.insert(new_g);
       }
       break;
     case Generator::CLOSURE_POINT:
       // If g is not the origin, insert g into new_gs, as a ray.
       if (!g.expr.all_homogeneous_terms_are_zero()) {
         // Turn a copy of g into a ray.
         Generator g_as_a_ray = g;
         g_as_a_ray.expr.set_inhomogeneous_term(0);
         g_as_a_ray.expr.normalize();
         PPL_ASSERT(g_as_a_ray.OK());
         // Insert the ray.
         new_gs.insert(g_as_a_ray);
       }
       break;
     case Generator::RAY:
     case Generator::LINE:
       // Insert g into new_gs.
       new_gs.insert(g);
       break;
     }
   }
   new_gs.add_corresponding_closure_points();
   // Notice: add_corresponding_closure_points adds them as pending.
   new_gs.unset_pending_rows();
 
   //Polyhedron new_x(...,new_gs);
   //swap(x,new_x);
 
   PPL_ASSERT(new_gs.sys.OK());
 
   // Stealing the rows from `new_gs'.
   using std::swap;
   swap(gen_sys, new_gs);
 
   gen_sys.set_sorted(false);
   clear_generators_minimized();
   // Generators are now up-to-date.
   set_generators_up_to_date();
   // Constraints are not up-to-date.
   clear_constraints_up_to_date();
 
   PPL_ASSERT_HEAVY(x.OK(true) && y.OK(true));
 }

void Parma_Polyhedra_Library::Polyhedron::print ( ) const

Prints *this to std::cerr using operator<<.

bool Parma_Polyhedra_Library::Polyhedron::process_pending ( ) const

inlineprivate

Processes the pending rows of either description of the polyhedron and obtains a minimized polyhedron.

Returns: false if and only if *this turns out to be an empty polyhedron.

It is assumed that the polyhedron does have some constraints or generators pending.

Definition at line 300 of file Polyhedron_inlines.hh.

References has_pending_constraints(), has_pending_generators(), has_something_pending(), marked_empty(), process_pending_constraints(), process_pending_generators(), and space_dim.

                                   {
   PPL_ASSERT(space_dim > 0 && !marked_empty());
   PPL_ASSERT(has_something_pending());
 
   if (has_pending_constraints()) {
     return process_pending_constraints();
   }
 
   PPL_ASSERT(has_pending_generators());
   process_pending_generators();
   return true;
 }

bool Parma_Polyhedra_Library::Polyhedron::process_pending_constraints ( ) const

private

Processes the pending constraints and obtains a minimized polyhedron.

Returns: false if and only if *this turns out to be an empty polyhedron.

It is assumed that the polyhedron does have some pending constraints.

Definition at line 737 of file Polyhedron_nonpublic.cc.

References clear_pending_constraints(), clear_sat_g_up_to_date(), con_sys, Parma_Polyhedra_Library::Implementation::BD_Shapes::empty, gen_sys, Parma_Polyhedra_Library::Constraint_System::is_sorted(), Parma_Polyhedra_Library::Constraint_System::num_pending_rows(), obtain_sorted_constraints_with_sat_c(), sat_c, sat_c_is_up_to_date(), sat_g, set_empty(), set_sat_c_up_to_date(), Parma_Polyhedra_Library::Constraint_System::sort_pending_and_remove_duplicates(), and Parma_Polyhedra_Library::Bit_Matrix::transpose_assign().

Referenced by limited_BHRZ03_extrapolation_assign(), limited_H79_extrapolation_assign(), poly_hull_assign(), positive_time_elapse_assign_impl(), process_pending(), remove_pending_to_obtain_generators(), and time_elapse_assign().

                                                  {
   PPL_ASSERT(space_dim > 0 && !marked_empty());
   PPL_ASSERT(has_pending_constraints() && !has_pending_generators());
 
   Polyhedron& x = const_cast<Polyhedron&>(*this);
 
   // Integrate the pending part of the system of constraints and minimize.
   // We need `sat_c' up-to-date and `con_sys' sorted (together with `sat_c').
   if (!x.sat_c_is_up_to_date()) {
     x.sat_c.transpose_assign(x.sat_g);
   }
   if (!x.con_sys.is_sorted()) {
     x.obtain_sorted_constraints_with_sat_c();
   }
   // We sort in place the pending constraints, erasing those constraints
   // that also occur in the non-pending part of `con_sys'.
   x.con_sys.sort_pending_and_remove_duplicates();
   if (x.con_sys.num_pending_rows() == 0) {
     // All pending constraints were duplicates.
     x.clear_pending_constraints();
     PPL_ASSERT_HEAVY(OK(true));
     return true;
   }
 
   const bool empty = add_and_minimize(true, x.con_sys, x.gen_sys, x.sat_c);
   PPL_ASSERT(x.con_sys.num_pending_rows() == 0);
 
   if (empty) {
     x.set_empty();
   }
   else {
     x.clear_pending_constraints();
     x.clear_sat_g_up_to_date();
     x.set_sat_c_up_to_date();
   }
   PPL_ASSERT_HEAVY(OK(!empty));
   return !empty;
 }

void Parma_Polyhedra_Library::Polyhedron::process_pending_generators ( ) const

private

Processes the pending generators and obtains a minimized polyhedron.

It is assumed that the polyhedron does have some pending generators.

Definition at line 777 of file Polyhedron_nonpublic.cc.

References clear_pending_generators(), clear_sat_c_up_to_date(), con_sys, gen_sys, Parma_Polyhedra_Library::Generator_System::is_sorted(), Parma_Polyhedra_Library::Generator_System::num_pending_rows(), obtain_sorted_generators_with_sat_g(), sat_c, sat_g, sat_g_is_up_to_date(), set_sat_g_up_to_date(), Parma_Polyhedra_Library::Generator_System::sort_pending_and_remove_duplicates(), and Parma_Polyhedra_Library::Bit_Matrix::transpose_assign().

Referenced by H79_widening_assign(), intersection_assign(), is_included_in(), process_pending(), and remove_pending_to_obtain_constraints().

                                                 {
   PPL_ASSERT(space_dim > 0 && !marked_empty());
   PPL_ASSERT(has_pending_generators() && !has_pending_constraints());
 
   Polyhedron& x = const_cast<Polyhedron&>(*this);
 
   // Integrate the pending part of the system of generators and minimize.
   // We need `sat_g' up-to-date and `gen_sys' sorted (together with `sat_g').
   if (!x.sat_g_is_up_to_date()) {
     x.sat_g.transpose_assign(x.sat_c);
   }
   if (!x.gen_sys.is_sorted()) {
     x.obtain_sorted_generators_with_sat_g();
   }
   // We sort in place the pending generators, erasing those generators
   // that also occur in the non-pending part of `gen_sys'.
   x.gen_sys.sort_pending_and_remove_duplicates();
   if (x.gen_sys.num_pending_rows() == 0) {
     // All pending generators were duplicates.
     x.clear_pending_generators();
     PPL_ASSERT_HEAVY(OK(true));
     return;
   }
 
   add_and_minimize(false, x.gen_sys, x.con_sys, x.sat_g);
   PPL_ASSERT(x.gen_sys.num_pending_rows() == 0);
 
   x.clear_pending_generators();
   x.clear_sat_c_up_to_date();
   x.set_sat_g_up_to_date();
 }

PPL::Polyhedron::Three_Valued_Boolean Parma_Polyhedra_Library::Polyhedron::quick_equivalence_test ( const Polyhedron & y ) const

private

Polynomial but incomplete equivalence test between polyhedra.

Definition at line 356 of file Polyhedron_nonpublic.cc.

References con_sys, constraints_are_minimized(), gen_sys, generators_are_minimized(), has_something_pending(), marked_empty(), Parma_Polyhedra_Library::Constraint_System::num_equalities(), Parma_Polyhedra_Library::Generator_System::num_lines(), Parma_Polyhedra_Library::Generator_System::num_rows(), Parma_Polyhedra_Library::Constraint_System::num_rows(), obtain_sorted_constraints(), obtain_sorted_generators(), space_dim, topology(), TVB_DONT_KNOW, TVB_FALSE, and TVB_TRUE.

Referenced by contains(), and operator==().

                                                                {
   // Private method: the caller must ensure the following.
   PPL_ASSERT(topology() == y.topology());
   PPL_ASSERT(space_dim == y.space_dim);
   PPL_ASSERT(!marked_empty() && !y.marked_empty() && space_dim > 0);
 
   const Polyhedron& x = *this;
 
   if (x.is_necessarily_closed()) {
     if (!x.has_something_pending() && !y.has_something_pending()) {
       bool css_normalized = false;
       if (x.constraints_are_minimized() && y.constraints_are_minimized()) {
         // Equivalent minimized constraint systems have:
         //  - the same number of constraints; ...
         if (x.con_sys.num_rows() != y.con_sys.num_rows()) {
           return Polyhedron::TVB_FALSE;
         }
         //  - the same number of equalities; ...
         const dimension_type x_num_equalities = x.con_sys.num_equalities();
         if (x_num_equalities != y.con_sys.num_equalities()) {
           return Polyhedron::TVB_FALSE;
         }
         //  - if there are no equalities, they have the same constraints.
         //    Delay this test: try cheaper tests on generators first.
         css_normalized = (x_num_equalities == 0);
       }
 
       if (x.generators_are_minimized() && y.generators_are_minimized()) {
         // Equivalent minimized generator systems have:
         //  - the same number of generators; ...
         if (x.gen_sys.num_rows() != y.gen_sys.num_rows()) {
           return Polyhedron::TVB_FALSE;
         }
         //  - the same number of lines; ...
         const dimension_type x_num_lines = x.gen_sys.num_lines();
         if (x_num_lines != y.gen_sys.num_lines()) {
           return Polyhedron::TVB_FALSE;
         }
         //  - if there are no lines, they have the same generators.
         if (x_num_lines == 0) {
           // Sort the two systems and check for syntactic identity.
           x.obtain_sorted_generators();
           y.obtain_sorted_generators();
           if (x.gen_sys == y.gen_sys) {
             return Polyhedron::TVB_TRUE;
           }
           else {
             return Polyhedron::TVB_FALSE;
           }
         }
       }
 
       if (css_normalized) {
         // Sort the two systems and check for identity.
         x.obtain_sorted_constraints();
         y.obtain_sorted_constraints();
         if (x.con_sys == y.con_sys) {
             return Polyhedron::TVB_TRUE;
         }
         else {
           return Polyhedron::TVB_FALSE;
         }
       }
     }
   }
   return Polyhedron::TVB_DONT_KNOW;
 }

template<typename FP_Format , typename Interval_Info >

void Parma_Polyhedra_Library::Polyhedron::refine_fp_interval_abstract_store ( Box< Interval< FP_Format, Interval_Info > > & store ) const

inline

Refines store with the constraints defining *this.

Parameters

store The interval floating point abstract store to refine.

Definition at line 416 of file Polyhedron_inlines.hh.

References PPL_COMPILE_TIME_CHECK.

                                                                {
 
   // Check that FP_Format is indeed a floating point type.
   PPL_COMPILE_TIME_CHECK(!std::numeric_limits<FP_Format>::is_exact,
                      "Polyhedron::refine_fp_interval_abstract_store:"
                      " T not a floating point type.");
 
   typedef Interval<FP_Format, Interval_Info> FP_Interval_Type;
   store.intersection_assign(Box<FP_Interval_Type>(*this));
 
 }

void Parma_Polyhedra_Library::Polyhedron::refine_no_check ( const Constraint & c )

private

Uses a copy of constraint c to refine the system of constraints of *this.

Parameters

c	The constraint to be added. If it is dimension-incompatible with `*this`, the behavior is undefined.

Definition at line 1434 of file Polyhedron_nonpublic.cc.

References Parma_Polyhedra_Library::Constraint::expression(), Parma_Polyhedra_Library::Constraint::is_equality(), Parma_Polyhedra_Library::Constraint::is_inconsistent(), Parma_Polyhedra_Library::Constraint::is_necessarily_closed(), and Parma_Polyhedra_Library::Constraint::space_dimension().

Referenced by poly_difference_assign().

                                                   {
   PPL_ASSERT(!marked_empty());
   PPL_ASSERT(space_dim >= c.space_dimension());
 
   // Dealing with a zero-dimensional space polyhedron first.
   if (space_dim == 0) {
     if (c.is_inconsistent()) {
       set_empty();
     }
     return;
   }
 
   // The constraints (possibly with pending rows) are required.
   if (has_pending_generators()) {
     process_pending_generators();
   }
   else if (!constraints_are_up_to_date()) {
     update_constraints();
   }
 
   const bool adding_pending = can_have_something_pending();
 
   if (c.is_necessarily_closed() || !is_necessarily_closed()) {
     // Since `con_sys' is not empty, the topology and space dimension
     // of the inserted constraint are automatically adjusted.
     if (adding_pending) {
       con_sys.insert_pending(c);
     }
     else {
       con_sys.insert(c);
     }
   }
   else {
     // Here we know that the system of constraints has at least a row.
     // However, by barely invoking `con_sys.insert(c)' we would
     // cause a change in the topology of `con_sys', which is wrong.
     // Thus, we insert a "topology corrected" copy of `c'.
     const Linear_Expression nc_expr(c.expression());
     if (c.is_equality()) {
       if (adding_pending) {
         con_sys.insert_pending(nc_expr == 0);
       }
       else {
         con_sys.insert(nc_expr == 0);
       }
     }
     else {
       if (adding_pending) {
         con_sys.insert_pending(nc_expr >= 0);
       }
       else {
         con_sys.insert(nc_expr >= 0);
       }
     }
   }
 
   if (adding_pending) {
     set_constraints_pending();
   }
   else {
     // Constraints are not minimized and generators are not up-to-date.
     clear_constraints_minimized();
     clear_generators_up_to_date();
   }
 
   // Note: the constraint system may have become unsatisfiable, thus
   // we do not check for satisfiability.
   PPL_ASSERT_HEAVY(OK());
 }

void Parma_Polyhedra_Library::Polyhedron::refine_with_congruence ( const Congruence & cg )

Uses a copy of congruence cg to refine *this.

Exceptions

std::invalid_argument Thrown if *this and congruence cg are dimension-incompatible.

Definition at line 1757 of file Polyhedron_public.cc.

References c, Parma_Polyhedra_Library::Constraint::EQUALITY, Parma_Polyhedra_Library::Congruence::expression(), Parma_Polyhedra_Library::Congruence::is_equality(), Parma_Polyhedra_Library::Congruence::is_tautological(), Parma_Polyhedra_Library::Boundary_NS::le(), Parma_Polyhedra_Library::NECESSARILY_CLOSED, and Parma_Polyhedra_Library::Congruence::space_dimension().

                                                           {
   // Dimension-compatibility check.
   if (space_dim < cg.space_dimension()) {
     throw_dimension_incompatible("refine_with_congruence(cg)", "cg", cg);
   }
 
   // If the polyhedron is known to be empty, do nothing.
   if (marked_empty()) {
     return;
   }
 
   // Dealing with a zero-dimensional space polyhedron first.
   if (space_dim == 0) {
     if (!cg.is_tautological()) {
       set_empty();
     }
     return;
   }
 
   if (cg.is_equality()) {
     Linear_Expression le(cg.expression());
     const Constraint c(le, Constraint::EQUALITY, NECESSARILY_CLOSED);
     refine_no_check(c);
   }
 }

void Parma_Polyhedra_Library::Polyhedron::refine_with_congruences ( const Congruence_System & cgs )

Uses a copy of the congruences in cgs to refine *this.

Parameters

cgs	Contains the congruences used to refine the system of constraints of `*this`.

Exceptions

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

Definition at line 1879 of file Polyhedron_public.cc.

References Parma_Polyhedra_Library::Congruence_System::begin(), c, Parma_Polyhedra_Library::Congruence_System::end(), Parma_Polyhedra_Library::Constraint::EQUALITY, Parma_Polyhedra_Library::Constraint_System::insert(), Parma_Polyhedra_Library::Boundary_NS::le(), Parma_Polyhedra_Library::NECESSARILY_CLOSED, and Parma_Polyhedra_Library::Congruence_System::space_dimension().

                                                                    {
   // Dimension-compatibility check.
   if (space_dim < cgs.space_dimension()) {
     throw_dimension_incompatible("refine_with_congruences(cgs)", "cgs", cgs);
   }
 
   Constraint_System cs;
   bool inserted = false;
   for (Congruence_System::const_iterator i = cgs.begin(),
          cgs_end = cgs.end(); i != cgs_end; ++i) {
     if (i->is_equality()) {
       Linear_Expression le(i->expression());
       const Constraint c(le, Constraint::EQUALITY, NECESSARILY_CLOSED);
 
       // TODO: Consider stealing the row in c when adding it to cs.
       cs.insert(c);
       inserted = true;
     }
     else if (i->is_inconsistent()) {
       set_empty();
       return;
     }
   }
   // Only add cgs if congruences were inserted into cgs, as the
   // dimension of cs must be at most that of the polyhedron.
   if (inserted) {
     add_recycled_constraints(cs);
   }
 }

void Parma_Polyhedra_Library::Polyhedron::refine_with_constraint ( const Constraint & c )

Uses a copy of constraint c to refine *this.

Exceptions

std::invalid_argument Thrown if *this and constraint c are dimension-incompatible.

Definition at line 1745 of file Polyhedron_public.cc.

References Parma_Polyhedra_Library::Constraint::space_dimension().

Referenced by refine_with_linear_form_inequality().

                                                          {
   // Dimension-compatibility check.
   if (space_dim < c.space_dimension()) {
     throw_dimension_incompatible("refine_with_constraint(c)", "c", c);
   }
   // If the polyhedron is known to be empty, do nothing.
   if (!marked_empty()) {
     refine_no_check(c);
   }
 }

void Parma_Polyhedra_Library::Polyhedron::refine_with_constraints ( const Constraint_System & cs )

Uses a copy of the constraints in cs to refine *this.

Parameters

cs	Contains the constraints used to refine the system of constraints of `*this`.

Exceptions

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

Definition at line 1784 of file Polyhedron_public.cc.

References Parma_Polyhedra_Library::Constraint_System::begin(), c, Parma_Polyhedra_Library::Constraint_System::end(), Parma_Polyhedra_Library::Constraint::expression(), Parma_Polyhedra_Library::Constraint_System::has_no_rows(), Parma_Polyhedra_Library::Constraint_System::insert_pending(), Parma_Polyhedra_Library::Constraint::is_equality(), Parma_Polyhedra_Library::Constraint::is_necessarily_closed(), Parma_Polyhedra_Library::Constraint_System::num_rows(), and Parma_Polyhedra_Library::Constraint_System::space_dimension().

                                                                   {
   // TODO: this is just an executable specification.
 
   // Dimension-compatibility check.
   const dimension_type cs_space_dim = cs.space_dimension();
   if (space_dim < cs_space_dim) {
     throw_dimension_incompatible("refine_with_constraints(cs)a",
                                  "cs", cs);
   }
   // Adding no constraints is a no-op.
   if (cs.has_no_rows()) {
     return;
   }
 
   if (space_dim == 0) {
     // In a 0-dimensional space the constraints are
     // tautologies (e.g., 0 == 0 or 1 >= 0 or 1 > 0) or
     // inconsistent (e.g., 1 == 0 or -1 >= 0 or 0 > 0).
     // In a system of constraints `begin()' and `end()' are equal
     // if and only if the system only contains tautologies.
     if (cs.begin() != cs.end()) {
       // There is a constraint, it must be inconsistent,
       // the polyhedron is empty.
       status.set_empty();
     }
     return;
   }
 
   if (marked_empty()) {
     return;
   }
 
   // The constraints (possibly with pending rows) are required.
   if (has_pending_generators()) {
     process_pending_generators();
   }
   else if (!constraints_are_up_to_date()) {
     update_constraints();
   }
 
   const bool adding_pending = can_have_something_pending();
   for (dimension_type i = cs.num_rows(); i-- > 0; ) {
     const Constraint& c = cs[i];
 
     if (c.is_necessarily_closed() || !is_necessarily_closed()) {
       // Since `con_sys' is not empty, the topology and space dimension
       // of the inserted constraint are automatically adjusted.
       if (adding_pending) {
         con_sys.insert_pending(c);
       }
       else {
         con_sys.insert(c);
       }
     }
     else {
       // Here we know that *this is necessarily closed so even if c is
       // topologically closed, by barely invoking `con_sys.insert(c)' we
       // would cause a change in the topology of `con_sys', which is
       // wrong.  Thus, we insert a topology closed and "topology
       // corrected" version of `c'.
       const Linear_Expression nc_expr(c.expression());
       if (c.is_equality()) {
         if (adding_pending) {
           con_sys.insert_pending(nc_expr == 0);
         }
         else {
           con_sys.insert(nc_expr == 0);
         }
       }
       else {
         if (adding_pending) {
           con_sys.insert_pending(nc_expr >= 0);
         }
         else {
           con_sys.insert(nc_expr >= 0);
         }
       }
     }
   }
 
   if (adding_pending) {
     set_constraints_pending();
   }
   else {
     // Constraints are not minimized and generators are not up-to-date.
     clear_constraints_minimized();
     clear_generators_up_to_date();
   }
 
   // Note: the constraint system may have become unsatisfiable, thus
   // we do not check for satisfiability.
   PPL_ASSERT_HEAVY(OK());
 }

template<typename FP_Format , typename Interval_Info >

void Parma_Polyhedra_Library::Polyhedron::refine_with_linear_form_inequality	(	const Linear_Form< Interval< FP_Format, Interval_Info > > &	left,
		const Linear_Form< Interval< FP_Format, Interval_Info > > &	right,
		bool	is_strict = `false`
	)

Refines *this with the constraint expressed by left $<$ right if is_strict is set, with the constraint left $\leq$ right otherwise.

Parameters

left	The linear form on intervals with floating point boundaries that is on the left of the comparison operator. All of its coefficients MUST be bounded.
right	The linear form on intervals with floating point boundaries that is on the right of the comparison operator. All of its coefficients MUST be bounded.
is_strict	True if the comparison is strict.

Exceptions

std::invalid_argument Thrown if left (or right) is dimension-incompatible with *this.

This function is used in abstract interpretation to model a filter that is generated by a comparison of two expressions that are correctly approximated by left and right respectively.

Definition at line 300 of file Polyhedron_templates.hh.

References convert_to_integer_expression(), is_necessarily_closed(), marked_empty(), overapproximate_linear_form(), PPL_COMPILE_TIME_CHECK, refine_with_constraint(), space_dim, and throw_dimension_incompatible().

Referenced by generalized_refine_with_linear_form_inequality().

                         {
 
   // Check that FP_Format is indeed a floating point type.
   PPL_COMPILE_TIME_CHECK(!std::numeric_limits<FP_Format>::is_exact,
                          "Polyhedron::refine_with_linear_form_inequality:"
                          " FP_Format not a floating point type.");
 
   // Dimension compatibility checks.
   // The dimensions of left and right should not be greater than the
   // dimension of *this.
   const dimension_type left_space_dim = left.space_dimension();
   if (space_dim < left_space_dim) {
     throw_dimension_incompatible(
           "refine_with_linear_form_inequality(l1, l2, s)", "l1", left);
   }
 
   const dimension_type right_space_dim = right.space_dimension();
   if (space_dim < right_space_dim) {
     throw_dimension_incompatible(
           "refine_with_linear_form_inequality(l1, l2, s)", "l2", right);
   }
 
   // We assume that the analyzer will not refine an unreachable test.
   PPL_ASSERT(!marked_empty());
 
   typedef Interval<FP_Format, Interval_Info> FP_Interval_Type;
   typedef Linear_Form<FP_Interval_Type> FP_Linear_Form;
 
   if (Floating_Point_Expression<FP_Interval_Type, float_ieee754_single>::
       overflows(left)) {
     return;
   }
 
   if (Floating_Point_Expression<FP_Interval_Type, float_ieee754_single>::
       overflows(right)) {
     return;
   }
 
   // Overapproximate left - right.
   FP_Linear_Form left_minus_right(left);
   left_minus_right -= right;
   if (Floating_Point_Expression<FP_Interval_Type, float_ieee754_single>::
       overflows(left_minus_right)) {
     return;
   }
 
   dimension_type lf_space_dim = left_minus_right.space_dimension();
   FP_Linear_Form lf_approx;
   overapproximate_linear_form(left_minus_right, lf_space_dim, lf_approx);
   if (Floating_Point_Expression<FP_Interval_Type, float_ieee754_single>::
       overflows(lf_approx)) {
     return;
   }
 
   // Normalize left - right.
   Linear_Expression lf_approx_le;
   convert_to_integer_expression(lf_approx, lf_space_dim, lf_approx_le);
 
   // Finally, do the refinement.
   if (!is_strict || is_necessarily_closed()) {
     refine_with_constraint(lf_approx_le <= 0);
   }
   else {
     refine_with_constraint(lf_approx_le < 0);
   }
 }

PPL::Poly_Con_Relation Parma_Polyhedra_Library::Polyhedron::relation_with ( const Constraint & c ) const

Returns the relations holding between the polyhedron *this and the constraint c.

Exceptions

std::invalid_argument Thrown if *this and constraint c are dimension-incompatible.

Definition at line 209 of file Polyhedron_public.cc.

References Parma_Polyhedra_Library::Constraint::inhomogeneous_term(), Parma_Polyhedra_Library::Poly_Con_Relation::is_disjoint(), Parma_Polyhedra_Library::Constraint::is_equality(), Parma_Polyhedra_Library::Poly_Con_Relation::is_included(), Parma_Polyhedra_Library::Constraint::is_inconsistent(), Parma_Polyhedra_Library::Constraint::is_strict_inequality(), Parma_Polyhedra_Library::Poly_Con_Relation::saturates(), and Parma_Polyhedra_Library::Constraint::space_dimension().

Referenced by BFT00_poly_hull_assign_if_exact(), BHRZ03_combining_constraints(), BHRZ03_evolving_points(), BHRZ03_evolving_rays(), BHZ09_C_poly_hull_assign_if_exact(), BHZ09_NNC_poly_hull_assign_if_exact(), and poly_difference_assign().

                                                       {
   // Dimension-compatibility check.
   if (space_dim < c.space_dimension()) {
     throw_dimension_incompatible("relation_with(c)", "c", c);
   }
 
   if (marked_empty()) {
     return Poly_Con_Relation::saturates()
       && Poly_Con_Relation::is_included()
       && Poly_Con_Relation::is_disjoint();
   }
   if (space_dim == 0) {
     if (c.is_inconsistent()) {
       if (c.is_strict_inequality() && c.inhomogeneous_term() == 0) {
         // The constraint 0 > 0 implicitly defines the hyperplane 0 = 0;
         // thus, the zero-dimensional point also saturates it.
         return Poly_Con_Relation::saturates()
           && Poly_Con_Relation::is_disjoint();
       }
       else {
         return Poly_Con_Relation::is_disjoint();
       }
     }
     else if (c.is_equality() || c.inhomogeneous_term() == 0) {
       return Poly_Con_Relation::saturates()
         && Poly_Con_Relation::is_included();
     }
     else {
       // The zero-dimensional point saturates
       // neither the positivity constraint 1 >= 0,
       // nor the strict positivity constraint 1 > 0.
       return Poly_Con_Relation::is_included();
     }
   }
 
   if ((has_pending_constraints() && !process_pending_constraints())
       || (!generators_are_up_to_date() && !update_generators())) {
     // The polyhedron is empty.
     return Poly_Con_Relation::saturates()
       && Poly_Con_Relation::is_included()
       && Poly_Con_Relation::is_disjoint();
   }
   return gen_sys.relation_with(c);
 }

PPL::Poly_Gen_Relation Parma_Polyhedra_Library::Polyhedron::relation_with ( const Generator & g ) const

Returns the relations holding between the polyhedron *this and the generator g.

Exceptions

std::invalid_argument Thrown if *this and generator g are dimension-incompatible.

Definition at line 255 of file Polyhedron_public.cc.

References Parma_Polyhedra_Library::Poly_Gen_Relation::nothing(), Parma_Polyhedra_Library::Generator::space_dimension(), and Parma_Polyhedra_Library::Poly_Gen_Relation::subsumes().

                                                      {
   // Dimension-compatibility check.
   if (space_dim < g.space_dimension()) {
     throw_dimension_incompatible("relation_with(g)", "g", g);
   }
 
   // The empty polyhedron cannot subsume a generator.
   if (marked_empty()) {
     return Poly_Gen_Relation::nothing();
   }
 
   // A universe polyhedron in a zero-dimensional space subsumes
   // all the generators of a zero-dimensional space.
   if (space_dim == 0) {
     return Poly_Gen_Relation::subsumes();
   }
 
   if (has_pending_generators()) {
     process_pending_generators();
   }
   else if (!constraints_are_up_to_date()) {
     update_constraints();
   }
   return
     con_sys.satisfies_all_constraints(g)
     ? Poly_Gen_Relation::subsumes()
     : Poly_Gen_Relation::nothing();
 }

PPL::Poly_Con_Relation Parma_Polyhedra_Library::Polyhedron::relation_with ( const Congruence & cg ) const

Returns the relations holding between the polyhedron *this and the congruence c.

Exceptions

std::invalid_argument Thrown if *this and congruence c are dimension-incompatible.

Definition at line 285 of file Polyhedron_public.cc.

                                                        {
   const dimension_type cg_space_dim = cg.space_dimension();
   // Dimension-compatibility check.
   if (space_dim < cg_space_dim) {
     throw_dimension_incompatible("relation_with(cg)", "cg", cg);
   }
 
   if (cg.is_equality()) {
     const Constraint c(cg);
     return relation_with(c);
   }
 
   if (marked_empty()) {
     return Poly_Con_Relation::saturates()
       && Poly_Con_Relation::is_included()
       && Poly_Con_Relation::is_disjoint();
   }
 
   if (space_dim == 0) {
     if (cg.is_inconsistent()) {
       return Poly_Con_Relation::is_disjoint();
     }
     else {
       return Poly_Con_Relation::saturates()
         && Poly_Con_Relation::is_included();
     }
   }
 
   if ((has_pending_constraints() && !process_pending_constraints())
       || (!generators_are_up_to_date() && !update_generators())) {
     // The polyhedron is empty.
     return Poly_Con_Relation::saturates()
       && Poly_Con_Relation::is_included()
       && Poly_Con_Relation::is_disjoint();
   }
   // Build the equality corresponding to the congruence (ignoring the modulus).
   Linear_Expression expr(cg.expression());
   const Constraint c(expr == 0);
 
   // The polyhedron is non-empty so that there exists a point.
   // For an arbitrary generator point, compute the scalar product with
   // the equality.
   PPL_DIRTY_TEMP_COEFFICIENT(sp_point);
   for (Generator_System::const_iterator gs_i = gen_sys.begin(),
          gs_end = gen_sys.end(); gs_i != gs_end; ++gs_i) {
     if (gs_i->is_point()) {
       Scalar_Products::assign(sp_point, c, *gs_i);
       expr -= sp_point;
       break;
     }
   }
 
   // Find two hyperplanes that satisfy the congruence and are near to
   // the generating point (so that the point lies on or between these
   // two hyperplanes).
   // Then use the relations between the polyhedron and the halfspaces
   // corresponding to the hyperplanes to determine the result.
 
   // Compute the distance from the point to an hyperplane.
   const Coefficient& modulus = cg.modulus();
   PPL_DIRTY_TEMP_COEFFICIENT(signed_distance);
   signed_distance = sp_point % modulus;
   if (signed_distance == 0) {
     // The point is lying on the hyperplane.
     return relation_with(expr == 0);
   }
   else {
     // The point is not lying on the hyperplane.
     expr += signed_distance;
   }
   // Build first halfspace constraint.
   const bool positive = (signed_distance > 0);
   const Constraint first_halfspace = positive ? (expr >= 0) : (expr <= 0);
 
   const Poly_Con_Relation first_rels = relation_with(first_halfspace);
   PPL_ASSERT(!first_rels.implies(Poly_Con_Relation::saturates())
              && !first_rels.implies(Poly_Con_Relation::is_disjoint()));
   if (first_rels.implies(Poly_Con_Relation::strictly_intersects())) {
     return Poly_Con_Relation::strictly_intersects();
   }
 
   // Build second halfspace.
   if (positive) {
     expr -= modulus;
   }
   else {
     expr += modulus;
   }
   const Constraint second_halfspace = positive ? (expr <= 0) : (expr >= 0);
 
   PPL_ASSERT(first_rels == Poly_Con_Relation::is_included());
   const Poly_Con_Relation second_rels = relation_with(second_halfspace);
   PPL_ASSERT(!second_rels.implies(Poly_Con_Relation::saturates())
              && !second_rels.implies(Poly_Con_Relation::is_disjoint()));
   if (second_rels.implies(Poly_Con_Relation::strictly_intersects())) {
     return Poly_Con_Relation::strictly_intersects();
   }
 
   PPL_ASSERT(second_rels == Poly_Con_Relation::is_included());
   return Poly_Con_Relation::is_disjoint();
 }

void Parma_Polyhedra_Library::Polyhedron::remove_higher_space_dimensions ( dimension_type new_dimension )

Removes the higher dimensions of the vector space so that the resulting space will have dimension new_dimension.

Exceptions

std::invalid_argument Thrown if new_dimensions is greater than the space dimension of *this.

Definition at line 353 of file Polyhedron_chdims.cc.

Referenced by Parma_Polyhedra_Library::Implementation::Termination::all_affine_quasi_ranking_functions_MS(), Parma_Polyhedra_Library::Implementation::Termination::all_affine_ranking_functions_MS(), and Parma_Polyhedra_Library::Termination_Helpers::all_affine_ranking_functions_PR().

                                                                           {
   // Dimension-compatibility check.
   if (new_dimension > space_dim) {
     throw_dimension_incompatible("remove_higher_space_dimensions(nd)",
                                  new_dimension);
   }
 
   // The removal of no dimensions from any polyhedron is a no-op.
   // Note that this case also captures the only legal removal of
   // dimensions from a polyhedron in a 0-dim space.
   if (new_dimension == space_dim) {
     PPL_ASSERT_HEAVY(OK());
     return;
   }
 
   // We need updated generators; note that keeping pending generators
   // is useless because constraints will be dropped anyway.
   if (marked_empty()
       || (has_something_pending() && !remove_pending_to_obtain_generators())
       || (!generators_are_up_to_date() && !update_generators())) {
     // Removing dimensions from the empty polyhedron:
     // just updates the space dimension.
     space_dim = new_dimension;
     con_sys.clear();
     PPL_ASSERT_HEAVY(OK());
     return;
   }
 
   if (new_dimension == 0) {
     // Removing all dimensions from a non-empty polyhedron:
     // just return the zero-dimensional universe polyhedron.
     set_zero_dim_univ();
     return;
   }
 
   gen_sys.set_space_dimension(new_dimension);
 
   // Constraints are not up-to-date and generators are not minimized.
   clear_constraints_up_to_date();
   clear_generators_minimized();
 
   // Update the space dimension.
   space_dim = new_dimension;
 
   PPL_ASSERT_HEAVY(OK(true));
 }

void Parma_Polyhedra_Library::Polyhedron::remove_pending_to_obtain_constraints ( ) const

private

Lazily integrates the pending descriptions of the polyhedron to obtain a constraint system without pending rows.

It is assumed that the polyhedron does have some constraints or generators pending.

Definition at line 810 of file Polyhedron_nonpublic.cc.

References clear_constraints_minimized(), clear_generators_up_to_date(), clear_pending_constraints(), con_sys, has_pending_constraints(), has_pending_generators(), process_pending_generators(), Parma_Polyhedra_Library::Constraint_System::set_sorted(), and Parma_Polyhedra_Library::Constraint_System::unset_pending_rows().

                                                           {
   PPL_ASSERT(has_something_pending());
 
   Polyhedron& x = const_cast<Polyhedron&>(*this);
 
   // If the polyhedron has pending constraints, simply unset them.
   if (x.has_pending_constraints()) {
     // Integrate the pending constraints, which are possibly not sorted.
     x.con_sys.set_sorted(false);
     x.con_sys.unset_pending_rows();
     x.clear_pending_constraints();
     x.clear_constraints_minimized();
     x.clear_generators_up_to_date();
   }
   else {
     PPL_ASSERT(x.has_pending_generators());
     // We must process the pending generators and obtain the
     // corresponding system of constraints.
     x.process_pending_generators();
   }
   PPL_ASSERT_HEAVY(OK(true));
 }

bool Parma_Polyhedra_Library::Polyhedron::remove_pending_to_obtain_generators ( ) const

private

Lazily integrates the pending descriptions of the polyhedron to obtain a generator system without pending rows.

Returns: false if and only if *this turns out to be an empty polyhedron.

It is assumed that the polyhedron does have some constraints or generators pending.

Definition at line 834 of file Polyhedron_nonpublic.cc.

References clear_constraints_up_to_date(), clear_generators_minimized(), clear_pending_generators(), gen_sys, has_pending_constraints(), has_pending_generators(), process_pending_constraints(), Parma_Polyhedra_Library::Generator_System::set_sorted(), and Parma_Polyhedra_Library::Generator_System::unset_pending_rows().

Referenced by map_space_dimensions().

                                                          {
   PPL_ASSERT(has_something_pending());
 
   Polyhedron& x = const_cast<Polyhedron&>(*this);
 
   // If the polyhedron has pending generators, simply unset them.
   if (x.has_pending_generators()) {
     // Integrate the pending generators, which are possibly not sorted.
     x.gen_sys.set_sorted(false);
     x.gen_sys.unset_pending_rows();
     x.clear_pending_generators();
     x.clear_generators_minimized();
     x.clear_constraints_up_to_date();
     PPL_ASSERT_HEAVY(OK(true));
     return true;
   }
   else {
     PPL_ASSERT(x.has_pending_constraints());
     // We must integrate the pending constraints and obtain the
     // corresponding system of generators.
     return x.process_pending_constraints();
   }
 }

void Parma_Polyhedra_Library::Polyhedron::remove_space_dimensions ( const Variables_Set & vars )

Removes all the specified dimensions from the vector space.

Parameters

vars	The set of Variable objects corresponding to the space dimensions to be removed.

Exceptions

std::invalid_argument Thrown if *this is dimension-incompatible with one of the Variable objects contained in vars.

Definition at line 301 of file Polyhedron_chdims.cc.

References Parma_Polyhedra_Library::Variables_Set::space_dimension().

Referenced by Parma_Polyhedra_Library::Termination_Helpers::all_affine_ranking_functions_PR_original().

                                                                 {
   // The removal of no dimensions from any polyhedron is a no-op.
   // Note that this case also captures the only legal removal of
   // dimensions from a polyhedron in a 0-dim space.
   if (vars.empty()) {
     PPL_ASSERT_HEAVY(OK());
     return;
   }
 
   // Dimension-compatibility check.
   const dimension_type min_space_dim = vars.space_dimension();
   if (space_dim < min_space_dim) {
     throw_dimension_incompatible("remove_space_dimensions(vs)", min_space_dim);
   }
 
   const dimension_type new_space_dim = space_dim - vars.size();
 
   // We need updated generators; note that keeping pending generators
   // is useless because the constraints will be dropped anyway.
   if (marked_empty()
       || (has_something_pending() && !remove_pending_to_obtain_generators())
       || (!generators_are_up_to_date() && !update_generators())) {
     // Removing dimensions from the empty polyhedron:
     // we clear `con_sys' since it could have contained the
     // unsatisfiable constraint of the wrong dimension.
     con_sys.clear();
     // Update the space dimension.
     space_dim = new_space_dim;
     PPL_ASSERT_HEAVY(OK());
     return;
   }
 
   // When removing _all_ dimensions from a non-empty polyhedron,
   // we obtain the zero-dimensional universe polyhedron.
   if (new_space_dim == 0) {
     set_zero_dim_univ();
     return;
   }
 
   gen_sys.remove_space_dimensions(vars);
 
   // Constraints are not up-to-date and generators are not minimized.
   clear_constraints_up_to_date();
   clear_generators_minimized();
 
   // Update the space dimension.
   space_dim = new_space_dim;
 
   PPL_ASSERT_HEAVY(OK(true));
 }

bool Parma_Polyhedra_Library::Polyhedron::sat_c_is_up_to_date ( ) const

inlineprivate

Returns true if the saturation matrix sat_c is up-to-date.

Definition at line 155 of file Polyhedron_inlines.hh.

References status, and Parma_Polyhedra_Library::Polyhedron::Status::test_sat_c_up_to_date().

Referenced by add_space_dimensions_and_embed(), can_have_something_pending(), obtain_sorted_constraints(), obtain_sorted_constraints_with_sat_c(), obtain_sorted_generators(), obtain_sorted_generators_with_sat_g(), operator=(), Polyhedron(), and process_pending_constraints().

                                       {
   return status.test_sat_c_up_to_date();
 }

bool Parma_Polyhedra_Library::Polyhedron::sat_g_is_up_to_date ( ) const

inlineprivate

Returns true if the saturation matrix sat_g is up-to-date.

Definition at line 160 of file Polyhedron_inlines.hh.

References status, and Parma_Polyhedra_Library::Polyhedron::Status::test_sat_g_up_to_date().

Referenced by BHZ09_C_poly_hull_assign_if_exact(), BHZ09_NNC_poly_hull_assign_if_exact(), can_have_something_pending(), obtain_sorted_constraints(), obtain_sorted_constraints_with_sat_c(), obtain_sorted_generators(), obtain_sorted_generators_with_sat_g(), operator=(), Polyhedron(), process_pending_generators(), and select_H79_constraints().

                                       {
   return status.test_sat_g_up_to_date();
 }

void Parma_Polyhedra_Library::Polyhedron::select_CH78_constraints	(	const Polyhedron &	y,
		Constraint_System &	cs_selection
	)		const

private

Copies to cs_selection the constraints of y corresponding to the definition of the CH78-widening of *this and y.

Definition at line 40 of file Polyhedron_widenings.cc.

References c, con_sys, constraints_are_minimized(), has_something_pending(), Parma_Polyhedra_Library::Constraint_System::insert(), marked_empty(), Parma_Polyhedra_Library::Constraint_System::num_rows(), space_dim, Parma_Polyhedra_Library::Constraint_System::topology(), and topology().

Referenced by H79_widening_assign().

                                                                  {
   // Private method: the caller must ensure the following conditions.
   PPL_ASSERT(topology() == y.topology()
          && topology() == cs_selection.topology()
          && space_dim == y.space_dim);
   PPL_ASSERT(!marked_empty()
          && !has_pending_constraints()
          && generators_are_up_to_date());
   PPL_ASSERT(!y.marked_empty()
          && !y.has_something_pending()
          && y.constraints_are_minimized());
 
   // A constraint in `y.con_sys' is copied to `cs_selection'
   // if it is satisfied by all the generators of `gen_sys'.
 
   // Note: the loop index `i' goes upward to avoid reversing
   // the ordering of the chosen constraints.
   for (dimension_type i = 0, end = y.con_sys.num_rows(); i < end; ++i) {
     const Constraint& c = y.con_sys[i];
     if (gen_sys.satisfied_by_all_generators(c)) {
       cs_selection.insert(c);
     }
   }
 }

void Parma_Polyhedra_Library::Polyhedron::select_H79_constraints	(	const Polyhedron &	y,
		Constraint_System &	cs_selected,
		Constraint_System &	cs_not_selected
	)		const

private

Splits the constraints of `x' into two subsets, depending on whether or not they are selected to compute the H79-widening of *this and y.

Definition at line 68 of file Polyhedron_widenings.cc.

Referenced by BHRZ03_widening_assign(), and H79_widening_assign().

                                                                    {
   // Private method: the caller must ensure the following conditions
   // (beside the inclusion `y <= x').
   PPL_ASSERT(topology() == y.topology()
          && topology() == cs_selected.topology()
          && topology() == cs_not_selected.topology());
   PPL_ASSERT(space_dim == y.space_dim);
   PPL_ASSERT(!marked_empty()
          && !has_pending_generators()
          && constraints_are_up_to_date());
   PPL_ASSERT(!y.marked_empty()
          && !y.has_something_pending()
          && y.constraints_are_minimized()
          && y.generators_are_up_to_date());
 
   // FIXME: this is a workaround for NNC polyhedra.
   if (!y.is_necessarily_closed()) {
     // Force strong minimization of constraints.
     y.strongly_minimize_constraints();
     // Recompute generators (without compromising constraint minimization).
     y.update_generators();
   }
 
   // Obtain a sorted copy of `y.sat_g'.
   if (!y.sat_g_is_up_to_date()) {
     y.update_sat_g();
   }
   Bit_Matrix tmp_sat_g = y.sat_g;
   // Remove from `tmp_sat_g' the rows corresponding to tautologies
   // (i.e., the positivity or epsilon-bounding constraints):
   // this is needed in order to widen the polyhedron and not the
   // corresponding homogenized polyhedral cone.
   const Constraint_System& y_cs = y.con_sys;
   const dimension_type old_num_rows = y_cs.num_rows();
   dimension_type num_rows = old_num_rows;
   for (dimension_type i = 0; i < num_rows; ++i) {
     if (y_cs[i].is_tautological()) {
       using std::swap;
       --num_rows;
       swap(tmp_sat_g[i], tmp_sat_g[num_rows]);
     }
   }
   tmp_sat_g.remove_trailing_rows(old_num_rows - num_rows);
   tmp_sat_g.sort_rows();
 
   // A constraint in `con_sys' is copied to `cs_selected'
   // if its behavior with respect to `y.gen_sys' is the same
   // as that of another constraint in `y.con_sys'.
   // otherwise it is copied to `cs_not_selected'.
   // Namely, we check whether the saturation row `buffer'
   // (built starting from the given constraint and `y.gen_sys')
   // is a row of the saturation matrix `tmp_sat_g'.
 
   // CHECKME: the following comment is only applicable when `y.gen_sys'
   // is minimized. In that case, the comment suggests that it would be
   // possible to use a fast (but incomplete) redundancy test based on
   // the number of saturators in `buffer'.
   // NOTE: If the considered constraint of `con_sys' does not
   // satisfy the saturation rule (see Section \ref prelims), then
   // it will not appear in the resulting constraint system,
   // because `tmp_sat_g' is built starting from a minimized polyhedron.
 
   // The size of `buffer' will reach sat.num_columns() bits.
   Bit_Row buffer;
   // Note: the loop index `i' goes upward to avoid reversing
   // the ordering of the chosen constraints.
   for (dimension_type i = 0, end = con_sys.num_rows(); i < end; ++i) {
     const Constraint& ci = con_sys[i];
     // The saturation row `buffer' is built considering
     // the `i'-th constraint of the polyhedron `x' and
     // all the generators of the polyhedron `y'.
     buffer.clear();
     for (dimension_type j = y.gen_sys.num_rows(); j-- > 0; ) {
       const int sp_sgn = Scalar_Products::sign(ci, y.gen_sys[j]);
       // We are assuming that `y <= x'.
       PPL_ASSERT(sp_sgn >= 0
              || (!is_necessarily_closed()
                  && ci.is_strict_inequality()
                  && y.gen_sys[j].is_point()));
       if (sp_sgn > 0) {
         buffer.set(j);
       }
     }
     // We check whether `buffer' is a row of `tmp_sat_g',
     // exploiting its sortedness in order to have faster comparisons.
     if (tmp_sat_g.sorted_contains(buffer)) {
       cs_selected.insert(ci);
     }
     else {
       cs_not_selected.insert(ci);
     }
   }
 }

void Parma_Polyhedra_Library::Polyhedron::set_constraints_minimized ( )

inlineprivate

Sets status to express that constraints are minimized.

Definition at line 211 of file Polyhedron_inlines.hh.

References Parma_Polyhedra_Library::Polyhedron::Status::set_c_minimized(), set_constraints_up_to_date(), and status.

Referenced by Polyhedron(), update_constraints(), and update_generators().

                                       {
   set_constraints_up_to_date();
   status.set_c_minimized();
 }

void Parma_Polyhedra_Library::Polyhedron::set_constraints_pending ( )

inlineprivate

Sets status to express that constraints are pending.

Definition at line 223 of file Polyhedron_inlines.hh.

References Parma_Polyhedra_Library::Polyhedron::Status::set_c_pending(), and status.

Referenced by intersection_assign().

                                     {
   status.set_c_pending();
 }

void Parma_Polyhedra_Library::Polyhedron::set_constraints_up_to_date ( )

inlineprivate

Sets status to express that constraints are up-to-date.

Definition at line 201 of file Polyhedron_inlines.hh.

References Parma_Polyhedra_Library::Polyhedron::Status::set_c_up_to_date(), and status.

Referenced by Polyhedron(), and set_constraints_minimized().

                                        {
   status.set_c_up_to_date();
 }

void Parma_Polyhedra_Library::Polyhedron::set_empty ( )

private

Sets status to express that the polyhedron is empty, clearing all corresponding matrices.

Definition at line 727 of file Polyhedron_nonpublic.cc.

Referenced by intersection_assign(), poly_difference_assign(), Polyhedron(), positive_time_elapse_assign_impl(), process_pending_constraints(), time_elapse_assign(), and update_generators().

                          {
   status.set_empty();
   // The polyhedron is empty: we can thus throw away everything.
   con_sys.clear();
   gen_sys.clear();
   sat_c.clear();
   sat_g.clear();
 }

void Parma_Polyhedra_Library::Polyhedron::set_generators_minimized ( )

inlineprivate

Sets status to express that generators are minimized.

Definition at line 217 of file Polyhedron_inlines.hh.

References Parma_Polyhedra_Library::Polyhedron::Status::set_g_minimized(), set_generators_up_to_date(), and status.

Referenced by update_constraints(), and update_generators().

                                      {
   set_generators_up_to_date();
   status.set_g_minimized();
 }

void Parma_Polyhedra_Library::Polyhedron::set_generators_pending ( )

inlineprivate

Sets status to express that generators are pending.

Definition at line 228 of file Polyhedron_inlines.hh.

References Parma_Polyhedra_Library::Polyhedron::Status::set_g_pending(), and status.

Referenced by poly_hull_assign(), and time_elapse_assign().

                                    {
   status.set_g_pending();
 }

void Parma_Polyhedra_Library::Polyhedron::set_generators_up_to_date ( )

inlineprivate

Sets status to express that generators are up-to-date.

Definition at line 206 of file Polyhedron_inlines.hh.

References Parma_Polyhedra_Library::Polyhedron::Status::set_g_up_to_date(), and status.

Referenced by Polyhedron(), and set_generators_minimized().

                                       {
   status.set_g_up_to_date();
 }

void Parma_Polyhedra_Library::Polyhedron::set_sat_c_up_to_date ( )

inlineprivate

Sets status to express that sat_c is up-to-date.

Definition at line 233 of file Polyhedron_inlines.hh.

References Parma_Polyhedra_Library::Polyhedron::Status::set_sat_c_up_to_date(), and status.

Referenced by obtain_sorted_constraints_with_sat_c(), obtain_sorted_generators(), obtain_sorted_generators_with_sat_g(), process_pending_constraints(), update_constraints(), and update_sat_c().

                                  {
   status.set_sat_c_up_to_date();
 }

void Parma_Polyhedra_Library::Polyhedron::set_sat_g_up_to_date ( )

inlineprivate

Sets status to express that sat_g is up-to-date.

Definition at line 238 of file Polyhedron_inlines.hh.

References Parma_Polyhedra_Library::Polyhedron::Status::set_sat_g_up_to_date(), and status.

Referenced by obtain_sorted_constraints(), obtain_sorted_constraints_with_sat_c(), obtain_sorted_generators_with_sat_g(), process_pending_generators(), update_generators(), and update_sat_g().

                                  {
   status.set_sat_g_up_to_date();
 }

void Parma_Polyhedra_Library::Polyhedron::set_zero_dim_univ ( )

private

Sets status to express that the polyhedron is the universe 0-dimension vector space, clearing all corresponding matrices.

Definition at line 719 of file Polyhedron_nonpublic.cc.

Referenced by map_space_dimensions(), Polyhedron(), and simplify_using_context_assign().

                                  {
   status.set_zero_dim_univ();
   space_dim = 0;
   con_sys.clear();
   gen_sys.clear();
 }

Constraint_System Parma_Polyhedra_Library::Polyhedron::simplified_constraints ( ) const

inlineprivate

If constraints are up-to-date, obtain a simplified copy of them.

Definition at line 354 of file Polyhedron_inlines.hh.

References con_sys, constraints_are_minimized(), constraints_are_up_to_date(), has_pending_constraints(), Parma_Polyhedra_Library::Constraint_System::num_pending_rows(), Parma_Polyhedra_Library::Constraint_System::simplify(), and Parma_Polyhedra_Library::Constraint_System::unset_pending_rows().

Referenced by Parma_Polyhedra_Library::Box< ITV >::Box().

                                          {
   PPL_ASSERT(constraints_are_up_to_date());
   Constraint_System cs(con_sys);
   if (cs.num_pending_rows() > 0) {
     cs.unset_pending_rows();
   }
   if (has_pending_constraints() || !constraints_are_minimized()) {
     cs.simplify();
   }
   return cs;
 }

template<typename Linear_System1 >

dimension_type Parma_Polyhedra_Library::Polyhedron::simplify	(	Linear_System1 &	sys,
		Bit_Matrix &	sat
	)

staticprivate

Uses Gauss' elimination method to simplify the result of conversion().

Returns: The rank of sys.

Parameters

sys	The system to simplify: it will be modified;
sat	The saturation matrix corresponding to `sys`.

sys may be modified by swapping some of its rows and by possibly removing some of them, if they turn out to be redundant.

If sys is a system of constraints, then the rows of sat are indexed by constraints and its columns are indexed by generators; otherwise, if sys is a system of generators, then the rows of sat are indexed by generators and its columns by constraints.

Given a system of constraints or a system of generators, this function simplifies it using Gauss' elimination method (to remove redundant equalities/lines), deleting redundant inequalities/rays/points and making back-substitution. The explanation that follows assumes that sys is a system of constraints. For the case when sys is a system of generators, a similar explanation can be obtain by applying duality.

The explanation relies on the notion of redundancy. (See the Introduction.)

First we make some observations that can help the reader in understanding the function:

Proposition: An inequality that is saturated by all the generators can be transformed to an equality.

In fact, by combining any number of generators that saturate the constraints, we obtain a generator that saturates the constraints too:

$\langle \vect{c}, \vect{r}_1 \rangle = 0 \land \langle \vect{c}, \vect{r}_2 \rangle = 0 \Rightarrow \langle \vect{c}, (\lambda_1 \vect{r}_1 + \lambda_2 \vect{r}_2) \rangle = \lambda_1 \langle \vect{c}, \vect{r}_1 \rangle + \lambda_2 \langle \vect{c}, \vect{r}_2 \rangle = 0,$

where $\lambda_1, \lambda_2$ can be any real number.

Definition at line 84 of file Polyhedron_simplify_templates.hh.

References Parma_Polyhedra_Library::compute_capacity(), Parma_Polyhedra_Library::Implementation::BD_Shapes::empty, Parma_Polyhedra_Library::NECESSARILY_CLOSED, Parma_Polyhedra_Library::Bit_Matrix::num_columns(), Parma_Polyhedra_Library::Bit_Matrix::remove_trailing_rows(), simplify_num_saturators_p, simplify_num_saturators_size, swap(), and Parma_Polyhedra_Library::swap().

Referenced by add_and_minimize(), and minimize().

                                                          {
   dimension_type num_rows = sys.num_rows();
   const dimension_type num_cols_sat = sat.num_columns();
 
   using std::swap;
 
   // Looking for the first inequality in `sys'.
   dimension_type num_lines_or_equalities = 0;
   while (num_lines_or_equalities < num_rows
          && sys[num_lines_or_equalities].is_line_or_equality()) {
     ++num_lines_or_equalities;
   }
 
   // `num_saturators[i]' will contain the number of generators
   // that saturate the constraint `sys[i]'.
   if (num_rows > simplify_num_saturators_size) {
     delete [] simplify_num_saturators_p;
     simplify_num_saturators_p = 0;
     simplify_num_saturators_size = 0;
     const size_t max_size
       = std::numeric_limits<size_t>::max() / sizeof(dimension_type);
     const size_t new_size = compute_capacity(num_rows, max_size);
     simplify_num_saturators_p = new dimension_type[new_size];
     simplify_num_saturators_size = new_size;
   }
   dimension_type* const num_saturators = simplify_num_saturators_p;
 
   bool sys_sorted = sys.is_sorted();
 
   // Computing the number of saturators for each inequality,
   // possibly identifying and swapping those that happen to be
   // equalities (see Proposition above).
   for (dimension_type i = num_lines_or_equalities; i < num_rows; ++i) {
     if (sat[i].empty()) {
       // The constraint `sys_rows[i]' is saturated by all the generators.
       // Thus, either it is already an equality or it can be transformed
       // to an equality (see Proposition above).
       sys.sys.rows[i].set_is_line_or_equality();
       // Note: simple normalization already holds.
       sys.sys.rows[i].sign_normalize();
       // We also move it just after all the other equalities,
       // so that system `sys_rows' keeps its partial sortedness.
       if (i != num_lines_or_equalities) {
         sys.sys.rows[i].m_swap(sys.sys.rows[num_lines_or_equalities]);
         swap(sat[i], sat[num_lines_or_equalities]);
         swap(num_saturators[i], num_saturators[num_lines_or_equalities]);
       }
       ++num_lines_or_equalities;
       // `sys' is no longer sorted.
       sys_sorted = false;
     }
     else {
       // There exists a generator which does not saturate `sys[i]',
       // so that `sys[i]' is indeed an inequality.
       // We store the number of its saturators.
       num_saturators[i] = num_cols_sat - sat[i].count_ones();
     }
   }
 
   sys.set_sorted(sys_sorted);
   PPL_ASSERT(sys.OK());
 
   // At this point, all the equalities of `sys' (included those
   // inequalities that we just transformed to equalities) have
   // indexes between 0 and `num_lines_or_equalities' - 1,
   // which is the property needed by method gauss().
   // We can simplify the system of equalities, obtaining the rank
   // of `sys' as result.
   const dimension_type rank = sys.gauss(num_lines_or_equalities);
 
   // Now the irredundant equalities of `sys' have indexes from 0
   // to `rank' - 1, whereas the equalities having indexes from `rank'
   // to `num_lines_or_equalities' - 1 are all redundant.
   // (The inequalities in `sys' have been left untouched.)
   // The rows containing equalities are not sorted.
 
   if (rank < num_lines_or_equalities) {
     // We identified some redundant equalities.
     // Moving them at the bottom of `sys':
     // - index `redundant' runs through the redundant equalities
     // - index `erasing' identifies the first row that should
     //   be erased after this loop.
     // Note that we exit the loop either because we have removed all
     // redundant equalities or because we have moved all the
     // inequalities.
     for (dimension_type redundant = rank,
            erasing = num_rows;
          redundant < num_lines_or_equalities
            && erasing > num_lines_or_equalities;
          ) {
       --erasing;
       sys.remove_row(redundant);
       swap(sat[redundant], sat[erasing]);
       swap(num_saturators[redundant], num_saturators[erasing]);
       ++redundant;
     }
     // Adjusting the value of `num_rows' to the number of meaningful
     // rows of `sys': `num_lines_or_equalities' - `rank' is the number of
     // redundant equalities moved to the bottom of `sys', which are
     // no longer meaningful.
     num_rows -= num_lines_or_equalities - rank;
 
     // If the above loop exited because it moved all inequalities, it may not
     // have removed all the rendundant rows.
     sys.remove_trailing_rows(sys.num_rows() - num_rows);
 
     PPL_ASSERT(sys.num_rows() == num_rows);
 
     sat.remove_trailing_rows(num_lines_or_equalities - rank);
 
     // Adjusting the value of `num_lines_or_equalities'.
     num_lines_or_equalities = rank;
   }
 
   const dimension_type old_num_rows = sys.num_rows();
 
   // Now we use the definition of redundancy (given in the Introduction)
   // to remove redundant inequalities.
 
   // First we check the saturation rule, which provides a necessary
   // condition for an inequality to be irredundant (i.e., it provides
   // a sufficient condition for identifying redundant inequalities).
   // Let
   //
   //   num_saturators[i] = num_sat_lines[i] + num_sat_rays_or_points[i],
   //   dim_lin_space = num_irredundant_lines,
   //   dim_ray_space
   //     = dim_vector_space - num_irredundant_equalities - dim_lin_space
   //     = num_columns - 1 - num_lines_or_equalities - dim_lin_space,
   //   min_sat_rays_or_points = dim_ray_space.
   //
   // An inequality saturated by less than `dim_ray_space' _rays/points_
   // is redundant. Thus we have the implication
   //
   //   (num_saturators[i] - num_sat_lines[i] < dim_ray_space)
   //      ==>
   //        redundant(sys[i]).
   //
   // Moreover, since every line saturates all inequalities, we also have
   //     dim_lin_space = num_sat_lines[i]
   // so that we can rewrite the condition above as follows:
   //
   //   (num_saturators[i] < num_columns - num_lines_or_equalities - 1)
   //      ==>
   //        redundant(sys[i]).
   //
   const dimension_type sys_num_columns
     = sys.topology() == NECESSARILY_CLOSED ? sys.space_dimension() + 1
                                            : sys.space_dimension() + 2;
   const dimension_type min_saturators
     = sys_num_columns - num_lines_or_equalities - 1;
   for (dimension_type i = num_lines_or_equalities; i < num_rows; ) {
     if (num_saturators[i] < min_saturators) {
       // The inequality `sys[i]' is redundant.
       --num_rows;
       sys.remove_row(i);
       swap(sat[i], sat[num_rows]);
       swap(num_saturators[i], num_saturators[num_rows]);
     }
     else {
       ++i;
     }
   }
 
   // Now we check the independence rule.
   for (dimension_type i = num_lines_or_equalities; i < num_rows; ) {
     bool redundant = false;
     // NOTE: in the inner loop, index `j' runs through _all_ the
     // inequalities and we do not test if `sat[i]' is strictly
     // contained into `sat[j]'.  Experimentation has shown that this
     // is faster than having `j' only run through the indexes greater
     // than `i' and also doing the test `strict_subset(sat[i],
     // sat[k])'.
     for (dimension_type j = num_lines_or_equalities; j < num_rows; ) {
       if (i == j) {
         // We want to compare different rows of `sys'.
         ++j;
       }
       else {
         // Let us recall that each generator lies on a facet of the
         // polyhedron (see the Introduction).
         // Given two constraints `c_1' and `c_2', if there are `m'
         // generators lying on the hyper-plane corresponding to `c_1',
         // the same `m' generators lie on the hyper-plane
         // corresponding to `c_2', too, and there is another one lying
         // on the latter but not on the former, then `c_2' is more
         // restrictive than `c_1', i.e., `c_1' is redundant.
         bool strict_subset;
         if (subset_or_equal(sat[j], sat[i], strict_subset)) {
           if (strict_subset) {
             // All the saturators of the inequality `sys[i]' are
             // saturators of the inequality `sys[j]' too,
             // and there exists at least one saturator of `sys[j]'
             // which is not a saturator of `sys[i]'.
             // It follows that inequality `sys[i]' is redundant.
             redundant = true;
             break;
           }
           else {
             // We have `sat[j] == sat[i]'.  Hence inequalities
             // `sys[i]' and `sys[j]' are saturated by the same set of
             // generators. Then we can remove either one of the two
             // inequalities: we remove `sys[j]'.
             --num_rows;
             sys.remove_row(j);
             PPL_ASSERT(sys.num_rows() == num_rows);
             swap(sat[j], sat[num_rows]);
             swap(num_saturators[j], num_saturators[num_rows]);
           }
         }
         else {
           // If we reach this point then we know that `sat[i]' does
           // not contain (and is different from) `sat[j]', so that
           // `sys[i]' is not made redundant by inequality `sys[j]'.
           ++j;
         }
       }
     }
     if (redundant) {
       // The inequality `sys[i]' is redundant.
       --num_rows;
       sys.remove_row(i);
       PPL_ASSERT(sys.num_rows() == num_rows);
       swap(sat[i], sat[num_rows]);
       swap(num_saturators[i], num_saturators[num_rows]);
     }
     else {
       // The inequality `sys[i]' is not redundant.
       ++i;
     }
   }
 
   // Here we physically remove the `sat' rows corresponding to the redundant
   // inequalities previously removed from `sys'.
   sat.remove_trailing_rows(old_num_rows - num_rows);
 
   // At this point the first `num_lines_or_equalities' rows of 'sys'
   // represent the irredundant equalities, while the remaining rows
   // (i.e., those having indexes from `num_lines_or_equalities' to
   // `num_rows' - 1) represent the irredundant inequalities.
 #ifndef NDEBUG
   // Check if the flag is set (that of the equalities is already set).
   for (dimension_type i = num_lines_or_equalities; i < num_rows; ++i) {
     PPL_ASSERT(sys[i].is_ray_or_point_or_inequality());
   }
 #endif
 
   // Finally, since now the sub-system (of `sys') of the irredundant
   // equalities is in triangular form, we back substitute each
   // variables with the expression obtained considering the equalities
   // starting from the last one.
   sys.back_substitute(num_lines_or_equalities);
 
   // The returned value is the number of irredundant equalities i.e.,
   // the rank of the sub-system of `sys' containing only equalities.
   // (See the Introduction for definition of lineality space dimension.)
   return num_lines_or_equalities;
 }

bool Parma_Polyhedra_Library::Polyhedron::simplify_using_context_assign ( const Polyhedron & y )

Assigns to *this a meet-preserving simplification of *this with respect to y. If false is returned, then the intersection is empty.

Exceptions

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

Definition at line 2155 of file Polyhedron_public.cc.

                                                                 {
   Polyhedron& x = *this;
   // Topology compatibility check.
   if (x.topology() != y.topology()) {
     throw_topology_incompatible("simplify_using_context_assign(y)", "y", y);
   }
   // Dimension-compatibility check.
   if (x.space_dim != y.space_dim) {
     throw_dimension_incompatible("simplify_using_context_assign(y)", "y", y);
   }
 
   // Filter away the zero-dimensional case.
   if (x.space_dim == 0) {
     if (y.is_empty()) {
       x.set_zero_dim_univ();
       return false;
     }
     else {
       return !x.is_empty();
     }
   }
 
   // If `y' is empty, the biggest enlargement for `x' is the universe.
   if (!y.minimize()) {
     Polyhedron ph(x.topology(), x.space_dim, UNIVERSE);
     m_swap(ph);
     return false;
   }
 
   // If `x' is empty, the intersection is empty.
   if (!x.minimize()) {
     // Search for a constraint of `y' that is not a tautology.
     PPL_ASSERT(!y.has_pending_generators() && y.constraints_are_up_to_date());
     for (dimension_type i = y.con_sys.num_rows(); i-- > 0; ) {
       const Constraint& y_con_sys_i = y.con_sys[i];
       if (!y_con_sys_i.is_tautological()) {
         // Found: we obtain a constraint `c' contradicting the one we
         // found, and assign to `x' the polyhedron `ph' with `c' as
         // the only constraint.
         Polyhedron ph(x.topology(), x.space_dim, UNIVERSE);
         const Linear_Expression le(y_con_sys_i.expression());
         switch (y_con_sys_i.type()) {
         case Constraint::EQUALITY:
           ph.refine_no_check(le == 1);
           break;
         case Constraint::NONSTRICT_INEQUALITY:
           ph.refine_no_check(le <= -1);
           break;
         case Constraint::STRICT_INEQUALITY:
           ph.refine_no_check(le == 0);
           break;
         }
         m_swap(ph);
         PPL_ASSERT_HEAVY(OK());
         return false;
       }
     }
     // `y' is the universe: `x' cannot be enlarged.
     return false;
   }
 
   PPL_ASSERT(x.constraints_are_minimized()
          && !x.has_something_pending()
          && y.generators_are_minimized()
          && !y.has_something_pending());
   const Constraint_System& x_cs = x.con_sys;
   const dimension_type x_cs_num_rows = x_cs.num_rows();
   const Generator_System& y_gs = y.gen_sys;
 
   // Record into `redundant_by_y' the info about which constraints of
   // `x' are redundant in the context `y'.  Count the number of
   // redundancies found.
   std::vector<bool> redundant_by_y(x_cs_num_rows, false);
   dimension_type num_redundant_by_y = 0;
   for (dimension_type i = 0; i < x_cs_num_rows; ++i) {
     if (y_gs.satisfied_by_all_generators(x_cs[i])) {
       redundant_by_y[i] = true;
       ++num_redundant_by_y;
     }
   }
 
   Constraint_System result_cs;
 
   if (num_redundant_by_y < x_cs_num_rows) {
     // Some constraints were not identified as redundant (yet?).
     const Constraint_System& y_cs = y.con_sys;
     const dimension_type y_cs_num_rows = y_cs.num_rows();
     // Compute into `z' the minimized intersection of `x' and `y'.
     const bool x_first = (x_cs_num_rows > y_cs_num_rows);
     Polyhedron z(x_first ? x : y);
     if (x_first) {
       z.add_constraints(y_cs);
     }
     else {
       // Only copy (and then recycle) the non-redundant constraints.
       Constraint_System tmp_cs;
       for (dimension_type i = 0; i < x_cs_num_rows; ++i) {
         if (!redundant_by_y[i]) {
           tmp_cs.insert(x_cs[i]);
         }
       }
       z.add_recycled_constraints(tmp_cs);
     }
     if (!z.minimize()) {
       // For necessarily closed polyhedra, the objective function is
       // the default, zero.  Moreover, the default maximization mode is
       // OK, since we are only interested in satisfiability.
       MIP_Problem lp;
       if (x.is_necessarily_closed()) {
         lp.add_space_dimensions_and_embed(x.space_dim);
         lp.add_constraints(y_cs);
       }
       else {
         // KLUDGE: temporarily mark `y_cs' if it was necessarily
         // closed, so that we can interpret the epsilon dimension as a
         // standard dimension. Be careful to reset the topology of `cs'
         // even on exceptional execution path.
         const_cast<Constraint_System&>(y_cs).mark_as_necessarily_closed();
         try {
           lp.add_space_dimensions_and_embed(x.space_dim+1);
           lp.add_constraints(y_cs);
           const_cast<Constraint_System&>(y_cs).mark_as_not_necessarily_closed();
         }
         catch (...) {
           const_cast<Constraint_System&>(y_cs).mark_as_not_necessarily_closed();
           throw;
         }
         // For not necessarily closed polyhedra, we maximize the
         // epsilon dimension as we want to rule out the possibility
         // that all solutions have epsilon = 0.  We are in this case
         // if and only if the maximal value for epsilon is 0.
         lp.set_objective_function(Variable(x.space_dim));
       }
       // We apply the following heuristics here: constraints of `x' that
       // are not made redundant by `y' are added to `lp' depending on
       // the number of generators of `y' they rule out (the more generators
       // they rule out, the sooner they are added).  Of course, as soon
       // as `lp' becomes unsatisfiable, we stop adding.
       std::vector<Ruled_Out_Pair>
         ruled_out_vec(x_cs_num_rows - num_redundant_by_y);
       for (dimension_type i = 0, j = 0; i < x_cs_num_rows; ++i) {
         if (!redundant_by_y[i]) {
           const Constraint& c = x_cs[i];
           const Topology_Adjusted_Scalar_Product_Sign sps(c);
           dimension_type num_ruled_out_generators = 0;
           for (Generator_System::const_iterator k = y_gs.begin(),
                  y_gs_end = y_gs.end(); k != y_gs_end; ++k) {
             const Generator& g = *k;
             const int sp_sign = sps(g, c);
             if (x.is_necessarily_closed()) {
               if (g.is_line()) {
                 // Lines must saturate the constraint.
                 if (sp_sign != 0) {
                   goto ruled_out;
                 }
               }
               else {
                 // `g' is either a ray, a point or a closure point.
                 if (c.is_inequality()) {
                   // `c' is a non-strict inequality.
                   if (sp_sign < 0) {
                     goto ruled_out;
                   }
                 }
                 else {
                   // `c' is an equality.
                   if (sp_sign != 0) {
                     goto ruled_out;
                   }
                 }
               }
             }
             else {
               // The topology is not necessarily closed.
               switch (g.type()) {
               case Generator::LINE:
                 // Lines must saturate the constraint.
                 if (sp_sign != 0) {
                   goto ruled_out;
                 }
                 break;
               case Generator::POINT:
                 // Have to perform the special test when dealing with
                 // a strict inequality.
                 switch (c.type()) {
                 case Constraint::EQUALITY:
                   if (sp_sign != 0) {
                     goto ruled_out;
                   }
                   break;
                 case Constraint::NONSTRICT_INEQUALITY:
                   if (sp_sign < 0) {
                     goto ruled_out;
                   }
                   break;
                 case Constraint::STRICT_INEQUALITY:
                   if (sp_sign <= 0) {
                     goto ruled_out;
                   }
                   break;
                 }
                 break;
               case Generator::RAY:
                 // Intentionally fall through.
               case Generator::CLOSURE_POINT:
                 if (c.is_inequality()) {
                   // Constraint `c' is either a strict or a non-strict
                   // inequality.
                   if (sp_sign < 0) {
                     goto ruled_out;
                   }
                 }
                 else {
                   // Constraint `c' is an equality.
                   if (sp_sign != 0) {
                     goto ruled_out;
                   }
                 }
                 break;
               }
             }
             // If we reach this point, `g' satisfies `c'.
             continue;
           ruled_out:
             ++num_ruled_out_generators;
           }
           ruled_out_vec[j].constraint_index = i;
           ruled_out_vec[j].num_ruled_out = num_ruled_out_generators;
           ++j;
         }
       }
       std::sort(ruled_out_vec.begin(), ruled_out_vec.end(),
                 Ruled_Out_Less_Than());
 
       for (std::vector<Ruled_Out_Pair>::const_iterator
              j = ruled_out_vec.begin(),
              ruled_out_vec_end = ruled_out_vec.end();
            j != ruled_out_vec_end;
            ++j) {
         const Constraint& c = x_cs[j->constraint_index];
         result_cs.insert(c);
         if (x.is_necessarily_closed()) {
           lp.add_constraint(c);
         }
         else {
           // KLUDGE: temporarily mark `c' as if it was necessarily
           // closed, so that we can interpret the epsilon dimension as a
           // standard dimension.  Be careful to reset the topology of `c'
           // also on exceptional execution paths.
           const_cast<Constraint&>(c).mark_as_necessarily_closed();
           try {
             lp.add_constraint(c);
             const_cast<Constraint&>(c).mark_as_not_necessarily_closed();
           }
           catch (...) {
             const_cast<Constraint&>(c).mark_as_not_necessarily_closed();
             throw;
           }
         }
         const MIP_Problem_Status status = lp.solve();
         switch (status) {
         case UNFEASIBLE_MIP_PROBLEM:
           break;
         case OPTIMIZED_MIP_PROBLEM:
           if (x.is_necessarily_closed()) {
             continue;
           }
           else {
             Coefficient num;
             Coefficient den;
             lp.optimal_value(num, den);
             if (num != 0) {
               continue;
             }
           }
           break;
         default:
           PPL_UNREACHABLE;
           break;
         }
         Polyhedron result_ph(x.topology(), x.space_dim, UNIVERSE);
         result_ph.add_constraints(result_cs);
         swap(x, result_ph);
         PPL_ASSERT_HEAVY(x.OK());
         return false;
       }
       // Cannot exit from here.
       PPL_UNREACHABLE;
     }
     else {
       // Here `z' is not empty and minimized.
       PPL_ASSERT(z.constraints_are_minimized()
              && z.generators_are_minimized()
              && !z.has_something_pending());
       const Constraint_System& z_cs = z.con_sys;
       const Generator_System& z_gs = z.gen_sys;
       const dimension_type z_gs_num_rows = z_gs.num_rows();
 
       // Compute the number of equalities in x_cs, y_cs and z_cs
       // (exploiting minimal form knowledge).
       dimension_type x_cs_num_eq = 0;
       while (x_cs[x_cs_num_eq].is_equality()) {
         ++x_cs_num_eq;
       }
       dimension_type y_cs_num_eq = 0;
       while (y_cs[y_cs_num_eq].is_equality()) {
         ++y_cs_num_eq;
       }
       dimension_type z_cs_num_eq = 0;
       while (z_cs[z_cs_num_eq].is_equality()) {
         ++z_cs_num_eq;
       }
       PPL_ASSERT(x_cs_num_eq <= z_cs_num_eq && y_cs_num_eq <= z_cs_num_eq);
 
       // Identify non-redundant equalities.
       Constraint_System non_redundant_eq;
       dimension_type num_non_redundant_eq = 0;
       const dimension_type needed_non_redundant_eq = z_cs_num_eq - y_cs_num_eq;
       Constraint_System eqs(x.topology());
       if (needed_non_redundant_eq > 0) {
         // Populate eqs with the equalities from y.
         for (dimension_type i = 0; i < y_cs_num_eq; ++i) {
           eqs.insert(y_cs[i]);
         }
         // Try to find another `needed_non_redundant_eq' linear independent
         // equalities among those from x.
         for (dimension_type i = 0; i < x_cs_num_eq; ++i) {
           const Constraint& x_cs_i = x_cs[i];
           if (add_to_system_and_check_independence(eqs, x_cs_i)) {
             // x_cs_i is linear independent.
             non_redundant_eq.insert(x_cs_i);
             ++num_non_redundant_eq;
             if (num_non_redundant_eq == needed_non_redundant_eq) {
               // Already found all the needed equalities.
               break;
             }
           }
         }
         // NOTE: if num_non_redundant_eq < needed_non_redundant_eq
         // then we haven't found all the needed equalities yet:
         // this means that some inequalities from x actually holds
         // as "masked" equalities in the context of y.
         PPL_ASSERT(eqs.num_rows() <= z_cs_num_eq);
         PPL_ASSERT(num_non_redundant_eq <= needed_non_redundant_eq);
         PPL_ASSERT(z_cs_num_eq - eqs.num_rows()
                == needed_non_redundant_eq - num_non_redundant_eq);
       }
 
       // Identify non-redundant inequalities.
       // Avoid useless copies (no modifications are needed).
       std::vector<const Constraint*> non_redundant_ineq_p;
       // Fill non_redundant_ineq_p with (pointers to) inequalities
       // from y_cs ...
       for (dimension_type i = y_cs_num_eq; i < y_cs_num_rows; ++i) {
         non_redundant_ineq_p.push_back(&y_cs[i]);
       }
       // ... and (pointers to) non-redundant inequalities from x_cs.
       for (dimension_type i = x_cs_num_eq; i < x_cs_num_rows; ++i) {
         if (!redundant_by_y[i]) {
           non_redundant_ineq_p.push_back(&x_cs[i]);
         }
       }
       const dimension_type non_redundant_ineq_p_size
         = non_redundant_ineq_p.size();
       const dimension_type y_cs_num_ineq = y_cs_num_rows - y_cs_num_eq;
 
       // Compute saturation info.
       const dimension_type sat_num_rows = non_redundant_ineq_p_size;
       Bit_Matrix sat(sat_num_rows, z_gs_num_rows);
       for (dimension_type i = sat_num_rows; i-- > 0; ) {
         const Constraint& non_redundant_ineq_i = *(non_redundant_ineq_p[i]);
         Bit_Row& sat_i = sat[i];
         for (dimension_type j = z_gs_num_rows; j-- > 0; ) {
           if (Scalar_Products::sign(non_redundant_ineq_i, z_gs[j]) != 0) {
             sat_i.set(j);
           }
         }
         if (sat_i.empty() && num_non_redundant_eq < needed_non_redundant_eq) {
           // `non_redundant_ineq_i' is actually masking an equality
           // and we are still looking for some masked inequalities.
           // Iteration goes downwards, so the inequality comes from x_cs.
           PPL_ASSERT(i >= y_cs_num_ineq);
           // Check if the equality is independent in eqs.
           Constraint masked_eq = non_redundant_ineq_i;
           masked_eq.set_is_line_or_equality();
           masked_eq.sign_normalize();
           if (add_to_system_and_check_independence(eqs, masked_eq)) {
             // It is independent: add the _inequality_ to non_redundant_eq.
             non_redundant_eq.insert(non_redundant_ineq_i);
             ++num_non_redundant_eq;
           }
         }
       }
       // Here we have already found all the needed (masked) equalities.
       PPL_ASSERT(num_non_redundant_eq == needed_non_redundant_eq);
 
       drop_redundant_inequalities(non_redundant_ineq_p, x.topology(),
                                   sat, z_cs_num_eq);
 
       // Place the non-redundant (masked) equalities into result_cs.
       swap(result_cs, non_redundant_eq);
       // Add to result_cs the non-redundant inequalities from x_cs,
       // i.e., those having indices no smaller than y_cs_num_ineq.
       for (dimension_type i = y_cs_num_ineq;
            i < non_redundant_ineq_p_size;
            ++i) {
         if (non_redundant_ineq_p[i] != 0) {
           result_cs.insert(*non_redundant_ineq_p[i]);
         }
       }
     }
   }
 
   Polyhedron result_ph(x.topology(), x.space_dim, UNIVERSE);
   result_ph.add_recycled_constraints(result_cs);
   swap(x, result_ph);
   PPL_ASSERT_HEAVY(x.OK());
   return true;
 }

dimension_type Parma_Polyhedra_Library::Polyhedron::space_dimension ( ) const

inline

Returns the dimension of the vector space enclosing *this.

Definition at line 40 of file Polyhedron_inlines.hh.

References space_dim.

                                   {
   return space_dim;
 }

bool Parma_Polyhedra_Library::Polyhedron::strictly_contains ( const Polyhedron & y ) const

inline

Returns true if and only if *this strictly contains y.

Exceptions

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

Definition at line 436 of file Polyhedron_inlines.hh.

References contains().

                                                        {
   const Polyhedron& x = *this;
   return x.contains(y) && !y.contains(x);
 }

bool Parma_Polyhedra_Library::Polyhedron::strongly_minimize_constraints ( ) const

private

Applies strong minimization to the constraints of an NNC polyhedron.

Returns: false if and only if *this turns out to be an empty polyhedron.

Definition at line 1148 of file Polyhedron_nonpublic.cc.

Referenced by select_H79_constraints().

                                                    {
   PPL_ASSERT(!is_necessarily_closed());
 
   // From the user perspective, the polyhedron will not change.
   Polyhedron& x = const_cast<Polyhedron&>(*this);
 
   // We need `con_sys' (weakly) minimized and `gen_sys' up-to-date.
   // `minimize()' will process any pending constraints or generators.
   if (!minimize()) {
     return false;
   }
   // If the polyhedron `*this' is zero-dimensional
   // at this point it must be a universe polyhedron.
   if (x.space_dim == 0) {
     return true;
   }
   // We also need `sat_g' up-to-date.
   if (!sat_g_is_up_to_date()) {
     PPL_ASSERT(sat_c_is_up_to_date());
     x.sat_g.transpose_assign(sat_c);
   }
 
   // These Bit_Row's will be later used as masks in order to
   // check saturation conditions restricted to particular subsets of
   // the generator system.
   Bit_Row sat_all_but_rays;
   Bit_Row sat_all_but_points;
   Bit_Row sat_all_but_closure_points;
 
   const dimension_type gs_rows = gen_sys.num_rows();
   const dimension_type n_lines = gen_sys.num_lines();
   for (dimension_type i = gs_rows; i-- > n_lines; ) {
     switch (gen_sys[i].type()) {
     case Generator::RAY:
       sat_all_but_rays.set(i);
       break;
     case Generator::POINT:
       sat_all_but_points.set(i);
       break;
     case Generator::CLOSURE_POINT:
       sat_all_but_closure_points.set(i);
       break;
     case Generator::LINE:
       // Found a line with index i >= n_lines !
       PPL_UNREACHABLE;
       break;
     }
   }
   const Bit_Row
     sat_lines_and_rays(sat_all_but_points, sat_all_but_closure_points);
   const Bit_Row
     sat_lines_and_closure_points(sat_all_but_rays, sat_all_but_points);
   const Bit_Row
     sat_lines(sat_lines_and_rays, sat_lines_and_closure_points);
 
   // These flags are maintained to later decide if we have to add the
   // eps_leq_one constraint and whether or not the constraint system
   // was changed.
   bool changed = false;
   bool found_eps_leq_one = false;
 
   // For all the strict inequalities in `con_sys', check for
   // eps-redundancy and eventually move them to the bottom part of the
   // system.
   Constraint_System& cs = x.con_sys;
   Bit_Matrix& sat = x.sat_g;
   const Variable eps_var(cs.space_dimension());
   // Note that cs.num_rows() is *not* constant because the calls to
   // cs.remove_row() decrease it.
   for (dimension_type i = 0; i < cs.num_rows(); ) {
     if (cs[i].is_strict_inequality()) {
       // First, check if it is saturated by no closure points
       Bit_Row sat_ci;
       sat_ci.union_assign(sat[i], sat_lines_and_closure_points);
       if (sat_ci == sat_lines) {
         // It is saturated by no closure points.
         if (!found_eps_leq_one) {
           // Check if it is the eps_leq_one constraint.
           const Constraint& c = cs[i];
           if (c.expression().all_homogeneous_terms_are_zero()
               && (c.expression().inhomogeneous_term() + c.epsilon_coefficient() == 0)) {
             // We found the eps_leq_one constraint.
             found_eps_leq_one = true;
             // Consider next constraint.
             ++i;
             continue;
           }
         }
         // Here `cs[i]' is not the eps_leq_one constraint,
         // so it is eps-redundant.
         // Remove it, while keeping `sat_g' consistent.
         cs.remove_row(i, false);
         swap(sat[i], sat[cs.num_rows()]);
         // The constraint system is changed.
         changed = true;
         // Continue by considering next constraint,
         // which is already in place due to the swap.
         continue;
       }
       // Now we check if there exists another strict inequality
       // constraint having a superset of its saturators,
       // when disregarding points.
       sat_ci.union_assign(sat[i], sat_all_but_points);
       bool eps_redundant = false;
       for (dimension_type j = 0; j < cs.num_rows(); ++j) {
         if (i != j && cs[j].is_strict_inequality()
             && subset_or_equal(sat[j], sat_ci)) {
           // Constraint `cs[i]' is eps-redundant:
           // remove it, while keeping `sat_g' consistent.
           cs.remove_row(i, false);
           swap(sat[i], sat[cs.num_rows()]);
           eps_redundant = true;
           // The constraint system is changed.
           changed = true;
           break;
         }
       }
       // Continue with next constraint, which is already in place
       // due to the swap if we have found an eps-redundant constraint.
       if (!eps_redundant) {
         ++i;
       }
     }
     else {
       // `cs[i]' is not a strict inequality: consider next constraint.
       ++i;
     }
   }
 
   PPL_ASSERT(cs.num_pending_rows() == 0);
 
   if (changed) {
     // If the constraint system has been changed, we have erased
     // the epsilon-redundant constraints.
 
     // The generator system is no longer up-to-date.
     x.clear_generators_up_to_date();
 
     // If we haven't found an upper bound for the epsilon dimension,
     // then we have to check whether such an upper bound is implied
     // by the remaining constraints (exploiting the simplex algorithm).
     if (!found_eps_leq_one) {
       MIP_Problem lp;
       // KLUDGE: temporarily mark the constraint system as if it was
       // necessarily closed, so that we can interpret the epsilon
       // dimension as a standard dimension. Be careful to reset the
       // topology of `cs' even on exceptional execution path.
       cs.mark_as_necessarily_closed();
       try {
         lp.add_space_dimensions_and_embed(cs.space_dimension());
         lp.add_constraints(cs);
         cs.mark_as_not_necessarily_closed();
       }
       catch (...) {
         cs.mark_as_not_necessarily_closed();
         throw;
       }
       // The objective function is `epsilon'.
       lp.set_objective_function(Variable(x.space_dim));
       lp.set_optimization_mode(MAXIMIZATION);
       const MIP_Problem_Status status = lp.solve();
       PPL_ASSERT(status != UNFEASIBLE_MIP_PROBLEM);
       // If the epsilon dimension is actually unbounded,
       // then add the eps_leq_one constraint.
       if (status == UNBOUNDED_MIP_PROBLEM) {
         cs.insert(Constraint::epsilon_leq_one());
       }
     }
   }
 
   PPL_ASSERT_HEAVY(OK());
   return true;
 }

bool Parma_Polyhedra_Library::Polyhedron::strongly_minimize_generators ( ) const

private

Applies strong minimization to the generators of an NNC polyhedron.

Returns: false if and only if *this turns out to be an empty polyhedron.

Definition at line 1323 of file Polyhedron_nonpublic.cc.

                                                   {
   PPL_ASSERT(!is_necessarily_closed());
 
   // From the user perspective, the polyhedron will not change.
   Polyhedron& x = const_cast<Polyhedron&>(*this);
 
   // We need `gen_sys' (weakly) minimized and `con_sys' up-to-date.
   // `minimize()' will process any pending constraints or generators.
   if (!minimize()) {
     return false;
   }
   // If the polyhedron `*this' is zero-dimensional
   // at this point it must be a universe polyhedron.
   if (x.space_dim == 0) {
     return true;
   }
 
   // We also need `sat_c' up-to-date.
   if (!sat_c_is_up_to_date()) {
     PPL_ASSERT(sat_g_is_up_to_date());
     x.sat_c.transpose_assign(sat_g);
   }
 
   // This Bit_Row will have all and only the indexes
   // of strict inequalities set to 1.
   Bit_Row sat_all_but_strict_ineq;
   const dimension_type cs_rows = con_sys.num_rows();
   const dimension_type n_equals = con_sys.num_equalities();
   for (dimension_type i = cs_rows; i-- > n_equals; ) {
     if (con_sys[i].is_strict_inequality()) {
       sat_all_but_strict_ineq.set(i);
     }
   }
 
   // Will record whether or not we changed the generator system.
   bool changed = false;
 
   // For all points in the generator system, check for eps-redundancy
   // and eventually move them to the bottom part of the system.
   Generator_System& gs = const_cast<Generator_System&>(gen_sys);
   Bit_Matrix& sat = const_cast<Bit_Matrix&>(sat_c);
   const dimension_type old_gs_rows = gs.num_rows();
   dimension_type gs_rows = old_gs_rows;
   const dimension_type n_lines = gs.num_lines();
   bool gs_sorted = gs.is_sorted();
 
   for (dimension_type i = n_lines; i < gs_rows; ) {
     Generator& g = gs.sys.rows[i];
     if (g.is_point()) {
       // Compute the Bit_Row corresponding to the candidate point
       // when strict inequality constraints are ignored.
       const Bit_Row sat_gs_i(sat[i], sat_all_but_strict_ineq);
       // Check if the candidate point is actually eps-redundant:
       // namely, if there exists another point that saturates
       // all the non-strict inequalities saturated by the candidate.
       bool eps_redundant = false;
       for (dimension_type j = n_lines; j < gs_rows; ++j) {
         const Generator& g2 = gs.sys.rows[j];
         if (i != j && g2.is_point() && subset_or_equal(sat[j], sat_gs_i)) {
           // Point `g' is eps-redundant:
           // move it to the bottom of the generator system,
           // while keeping `sat_c' consistent.
           --gs_rows;
           swap(g, gs.sys.rows[gs_rows]);
           swap(sat[i], sat[gs_rows]);
           eps_redundant = true;
           changed = true;
           break;
         }
       }
       if (!eps_redundant) {
         // Let all point encodings have epsilon coordinate 1.
         if (g.epsilon_coefficient() != g.expr.inhomogeneous_term()) {
           g.set_epsilon_coefficient(g.expr.inhomogeneous_term());
           // Enforce normalization.
           g.expr.normalize();
           PPL_ASSERT(g.OK());
           changed = true;
         }
         // Consider next generator.
         ++i;
       }
     }
     else {
       // Consider next generator.
       ++i;
     }
   }
 
   // If needed, erase the eps-redundant generators.
   if (gs_rows < old_gs_rows) {
     gs.sys.rows.resize(gs_rows);
   }
 
   if (changed) {
     // The generator system is no longer sorted.
     gs_sorted = false;
     // The constraint system is no longer up-to-date.
     x.clear_constraints_up_to_date();
   }
 
   gs.sys.index_first_pending = gs.num_rows();
   gs.set_sorted(gs_sorted);
 
   PPL_ASSERT(gs.sys.OK());
 
   PPL_ASSERT_HEAVY(OK());
   return true;
 }

void Parma_Polyhedra_Library::Polyhedron::throw_dimension_incompatible	(	const char *	method,
		const char *	other_name,
		dimension_type	other_dim
	)		const

protected

Definition at line 2609 of file Polyhedron_nonpublic.cc.

Referenced by affine_form_image(), H79_widening_assign(), refine_with_linear_form_inequality(), and throw_dimension_incompatible().

                                                                               {
   std::ostringstream s;
   s << "PPL::"
     << (is_necessarily_closed() ? "C_" : "NNC_")
     << "Polyhedron::" << method << ":\n"
     << "this->space_dimension() == " << space_dimension() << ", "
     << other_name << ".space_dimension() == " << other_dim << ".";
   throw std::invalid_argument(s.str());
 }

void Parma_Polyhedra_Library::Polyhedron::throw_dimension_incompatible	(	const char *	method,
		const char *	ph_name,
		const Polyhedron &	ph
	)		const

protected

Definition at line 2622 of file Polyhedron_nonpublic.cc.

References space_dimension().

                                                                           {
   throw_dimension_incompatible(method, ph_name, ph.space_dimension());
 }

void Parma_Polyhedra_Library::Polyhedron::throw_dimension_incompatible	(	const char *	method,
		const char *	le_name,
		const Linear_Expression &	le
	)		const

protected

Definition at line 2630 of file Polyhedron_nonpublic.cc.

References Parma_Polyhedra_Library::Linear_Expression::space_dimension().

                                                                   {
   throw_dimension_incompatible(method, le_name, le.space_dimension());
 }

void Parma_Polyhedra_Library::Polyhedron::throw_dimension_incompatible	(	const char *	method,
		const char *	c_name,
		const Constraint &	c
	)		const

protected

Definition at line 2637 of file Polyhedron_nonpublic.cc.

References Parma_Polyhedra_Library::Constraint::space_dimension().

                                                                          {
   throw_dimension_incompatible(method, c_name, c.space_dimension());
 }

void Parma_Polyhedra_Library::Polyhedron::throw_dimension_incompatible	(	const char *	method,
		const char *	g_name,
		const Generator &	g
	)		const

protected

Definition at line 2644 of file Polyhedron_nonpublic.cc.

References Parma_Polyhedra_Library::Generator::space_dimension().

                                                                         {
   throw_dimension_incompatible(method, g_name, g.space_dimension());
 }

void Parma_Polyhedra_Library::Polyhedron::throw_dimension_incompatible	(	const char *	method,
		const char *	cg_name,
		const Congruence &	cg
	)		const

protected

Definition at line 2651 of file Polyhedron_nonpublic.cc.

References Parma_Polyhedra_Library::Congruence::space_dimension().

                                                                           {
   throw_dimension_incompatible(method, cg_name, cg.space_dimension());
 }

void Parma_Polyhedra_Library::Polyhedron::throw_dimension_incompatible	(	const char *	method,
		const char *	cs_name,
		const Constraint_System &	cs
	)		const

protected

Definition at line 2658 of file Polyhedron_nonpublic.cc.

References Parma_Polyhedra_Library::Constraint_System::space_dimension().

                                                                                  {
   throw_dimension_incompatible(method, cs_name, cs.space_dimension());
 }

void Parma_Polyhedra_Library::Polyhedron::throw_dimension_incompatible	(	const char *	method,
		const char *	gs_name,
		const Generator_System &	gs
	)		const

protected

Definition at line 2666 of file Polyhedron_nonpublic.cc.

References Parma_Polyhedra_Library::Generator_System::space_dimension().

                                                                  {
   throw_dimension_incompatible(method, gs_name, gs.space_dimension());
 }

void Parma_Polyhedra_Library::Polyhedron::throw_dimension_incompatible	(	const char *	method,
		const char *	cgs_name,
		const Congruence_System &	cgs
	)		const

protected

Definition at line 2674 of file Polyhedron_nonpublic.cc.

References Parma_Polyhedra_Library::Congruence_System::space_dimension().

                                                                    {
   throw_dimension_incompatible(method, cgs_name, cgs.space_dimension());
 }

template<typename C >

void Parma_Polyhedra_Library::Polyhedron::throw_dimension_incompatible	(	const char *	method,
		const char *	lf_name,
		const Linear_Form< C > &	lf
	)		const

protected

Definition at line 591 of file Polyhedron_templates.hh.

References Parma_Polyhedra_Library::Linear_Form< C >::space_dimension(), and throw_dimension_incompatible().

                                                                          {
   throw_dimension_incompatible(method, lf_name, lf.space_dimension());
 }

void Parma_Polyhedra_Library::Polyhedron::throw_dimension_incompatible	(	const char *	method,
		const char *	var_name,
		Variable	var
	)		const

protected

Definition at line 2681 of file Polyhedron_nonpublic.cc.

References Parma_Polyhedra_Library::Variable::space_dimension().

                                                                         {
   std::ostringstream s;
   s << "PPL::";
   if (is_necessarily_closed()) {
     s << "C_";
   }
   else {
     s << "NNC_";
   }
   s << "Polyhedron::" << method << ":" << std::endl
     << "this->space_dimension() == " << space_dimension() << ", "
     << var_name << ".space_dimension() == " << var.space_dimension() << ".";
   throw std::invalid_argument(s.str());
 }

void Parma_Polyhedra_Library::Polyhedron::throw_dimension_incompatible	(	const char *	method,
		dimension_type	required_space_dim
	)		const

protected

Definition at line 2700 of file Polyhedron_nonpublic.cc.

                                                                       {
   std::ostringstream s;
   s << "PPL::";
   if (is_necessarily_closed()) {
     s << "C_";
   }
   else {
     s << "NNC_";
   }
   s << "Polyhedron::" << method << ":" << std::endl
     << "this->space_dimension() == " << space_dimension()
     << ", required space dimension == " << required_space_dim << ".";
   throw std::invalid_argument(s.str());
 }

void Parma_Polyhedra_Library::Polyhedron::throw_invalid_argument	(	const char *	method,
		const char *	reason
	)		const

protected

Definition at line 2526 of file Polyhedron_nonpublic.cc.

Referenced by map_space_dimensions().

                                                                   {
   std::ostringstream s;
   s << "PPL::";
   if (is_necessarily_closed()) {
     s << "C_";
   }
   else {
     s << "NNC_";
   }
   s << "Polyhedron::" << method << ":" << std::endl
     << reason << ".";
   throw std::invalid_argument(s.str());
 }

void Parma_Polyhedra_Library::Polyhedron::throw_invalid_generator	(	const char *	method,
		const char *	g_name
	)		const

protected

Definition at line 2737 of file Polyhedron_nonpublic.cc.

                                                                    {
   std::ostringstream s;
   s << "PPL::";
   if (is_necessarily_closed()) {
     s << "C_";
   }
   else {
     s << "NNC_";
   }
   s << "Polyhedron::" << method << ":" << std::endl
     << "*this is an empty polyhedron and "
     << g_name << " is not a point.";
   throw std::invalid_argument(s.str());
 }

void Parma_Polyhedra_Library::Polyhedron::throw_invalid_generators	(	const char *	method,
		const char *	gs_name
	)		const

protected

Definition at line 2754 of file Polyhedron_nonpublic.cc.

Referenced by Polyhedron().

                                                                      {
   std::ostringstream s;
   s << "PPL::";
   if (is_necessarily_closed()) {
     s << "C_";
   }
   else {
     s << "NNC_";
   }
   s << "Polyhedron::" << method << ":" << std::endl
     << "*this is an empty polyhedron and" << std::endl
     << "the non-empty generator system " << gs_name << " contains no points.";
   throw std::invalid_argument(s.str());
 }

void Parma_Polyhedra_Library::Polyhedron::throw_topology_incompatible	(	const char *	method,
		const char *	ph_name,
		const Polyhedron &	ph
	)		const

protected

Definition at line 2542 of file Polyhedron_nonpublic.cc.

References is_necessarily_closed().

Referenced by H79_widening_assign(), m_swap(), and Polyhedron().

                                                                          {
   std::ostringstream s;
   s << "PPL::";
   if (is_necessarily_closed()) {
     s << "C_";
   }
   else {
     s << "NNC_";
   }
   s << "Polyhedron::" << method << ":" << std::endl
     << ph_name << " is a ";
   if (ph.is_necessarily_closed()) {
     s << "C_";
   }
   else {
     s << "NNC_";
   }
   s << "Polyhedron." << std::endl;
   throw std::invalid_argument(s.str());
 }

void Parma_Polyhedra_Library::Polyhedron::throw_topology_incompatible	(	const char *	method,
		const char *	c_name,
		const Constraint &	c
	)		const

protected

Definition at line 2566 of file Polyhedron_nonpublic.cc.

                                                                       {
   PPL_ASSERT(is_necessarily_closed());
   std::ostringstream s;
   s << "PPL::C_Polyhedron::" << method << ":" << std::endl
     << c_name << " is a strict inequality.";
   throw std::invalid_argument(s.str());
 }

void Parma_Polyhedra_Library::Polyhedron::throw_topology_incompatible	(	const char *	method,
		const char *	g_name,
		const Generator &	g
	)		const

protected

Definition at line 2577 of file Polyhedron_nonpublic.cc.

                                                                      {
   PPL_ASSERT(is_necessarily_closed());
   std::ostringstream s;
   s << "PPL::C_Polyhedron::" << method << ":" << std::endl
     << g_name << " is a closure point.";
   throw std::invalid_argument(s.str());
 }

void Parma_Polyhedra_Library::Polyhedron::throw_topology_incompatible	(	const char *	method,
		const char *	cs_name,
		const Constraint_System &	cs
	)		const

protected

Definition at line 2588 of file Polyhedron_nonpublic.cc.

                                                                              {
   PPL_ASSERT(is_necessarily_closed());
   std::ostringstream s;
   s << "PPL::C_Polyhedron::" << method << ":" << std::endl
     << cs_name << " contains strict inequalities.";
   throw std::invalid_argument(s.str());
 }

void Parma_Polyhedra_Library::Polyhedron::throw_topology_incompatible	(	const char *	method,
		const char *	gs_name,
		const Generator_System &	gs
	)		const

protected

Definition at line 2599 of file Polyhedron_nonpublic.cc.

                                                                             {
   std::ostringstream s;
   s << "PPL::C_Polyhedron::" << method << ":" << std::endl
     << gs_name << " contains closure points.";
   throw std::invalid_argument(s.str());
 }

void Parma_Polyhedra_Library::Polyhedron::time_elapse_assign ( const Polyhedron & y )

Assigns to *this the result of computing the time-elapse between *this and y.

Exceptions

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

Definition at line 3603 of file Polyhedron_public.cc.

Referenced by Parma_Polyhedra_Library::Octagonal_Shape< T >::time_elapse_assign(), and Parma_Polyhedra_Library::BD_Shape< T >::time_elapse_assign().

                                                      {
   Polyhedron& x = *this;
   // Topology compatibility check.
   if (x.topology() != y.topology()) {
     throw_topology_incompatible("time_elapse_assign(y)", "y", y);
   }
   // Dimension-compatibility checks.
   if (x.space_dim != y.space_dim) {
     throw_dimension_incompatible("time_elapse_assign(y)", "y", y);
   }
 
   // Dealing with the zero-dimensional case.
   if (x.space_dim == 0) {
     if (y.marked_empty()) {
       x.set_empty();
     }
     return;
   }
 
   // If either one of `x' or `y' is empty, the result is empty too.
   if (x.marked_empty() || y.marked_empty()
       || (x.has_pending_constraints() && !x.process_pending_constraints())
       || (!x.generators_are_up_to_date() && !x.update_generators())
       || (y.has_pending_constraints() && !y.process_pending_constraints())
       || (!y.generators_are_up_to_date() && !y.update_generators())) {
     x.set_empty();
     return;
   }
 
   // At this point both generator systems are up-to-date,
   // possibly containing pending generators.
   Generator_System gs = y.gen_sys;
   const dimension_type old_gs_num_rows = gs.num_rows();
   dimension_type gs_num_rows = old_gs_num_rows;
 
   if (!x.is_necessarily_closed()) {
     // `x' and `y' are NNC polyhedra.
     for (dimension_type i = gs_num_rows; i-- > 0; ) {
       Generator& g = gs.sys.rows[i];
       switch (g.type()) {
       case Generator::POINT:
         // The points of `gs' can be erased,
         // since their role can be played by closure points.
         --gs_num_rows;
         swap(g, gs.sys.rows[gs_num_rows]);
         break;
       case Generator::CLOSURE_POINT:
         {
           // If it is the origin, erase it.
           if (g.expr.all_homogeneous_terms_are_zero()) {
             --gs_num_rows;
             swap(g, gs.sys.rows[gs_num_rows]);
           }
           // Otherwise, transform the closure point into a ray.
           else {
             g.expr.set_inhomogeneous_term(0);
             // Enforce normalization.
             g.expr.normalize();
             PPL_ASSERT(g.OK());
           }
         }
         break;
       case Generator::RAY:
       case Generator::LINE:
         // For rays and lines, nothing to be done.
         break;
       }
     }
   }
   else {
     // `x' and `y' are C polyhedra.
     for (dimension_type i = gs_num_rows; i-- > 0; ) {
       // For rays and lines, nothing to be done.
       if (gs[i].is_point()) {
         Generator& p = gs.sys.rows[i];
         // If it is the origin, erase it.
         if (p.expression().all_homogeneous_terms_are_zero()) {
           --gs_num_rows;
           swap(p, gs.sys.rows[gs_num_rows]);
         }
         // Otherwise, transform the point into a ray.
         else {
           p.expr.set_inhomogeneous_term(0);
           // Enforce normalization.
           p.expr.normalize();
           PPL_ASSERT(p.OK());
         }
       }
     }
   }
   // If it was present, erase the origin point or closure point,
   // which cannot be transformed into a valid ray or line.
   // For NNC polyhedra, also erase all the points of `gs',
   // whose role can be played by the closure points.
   // These have been previously moved to the end of `gs'.
   gs.sys.rows.resize(gs_num_rows);
 
   gs.unset_pending_rows();
   PPL_ASSERT(gs.sys.OK());
 
   // `gs' may now have no rows.
   // Namely, this happens when `y' was the singleton polyhedron
   // having the origin as the one and only point.
   // In such a case, the resulting polyhedron is equal to `x'.
   if (gs_num_rows == 0) {
     return;
   }
   // If the polyhedron can have something pending, we add `gs'
   // to `gen_sys' as pending rows
   if (x.can_have_something_pending()) {
     x.gen_sys.insert_pending(gs);
     x.set_generators_pending();
   }
   // Otherwise, the two systems are merged.
   // `Linear_System::merge_rows_assign()' requires both systems to be sorted.
   else {
     if (!x.gen_sys.is_sorted()) {
       x.gen_sys.sort_rows();
     }
     gs.sort_rows();
     x.gen_sys.merge_rows_assign(gs);
     // Only the system of generators is up-to-date.
     x.clear_constraints_up_to_date();
     x.clear_generators_minimized();
   }
   PPL_ASSERT_HEAVY(x.OK(true) && y.OK(true));
 }

void Parma_Polyhedra_Library::Polyhedron::topological_closure_assign ( )

Assigns to *this its topological closure.

Definition at line 3817 of file Polyhedron_public.cc.

References c, Parma_Polyhedra_Library::Constraint::epsilon_coefficient(), Parma_Polyhedra_Library::Constraint::epsilon_leq_one(), Parma_Polyhedra_Library::Constraint::expr, Parma_Polyhedra_Library::Constraint::is_tautological(), Parma_Polyhedra_Library::Linear_Expression::normalize(), Parma_Polyhedra_Library::Constraint::OK(), and Parma_Polyhedra_Library::Constraint::set_epsilon_coefficient().

                                           {
   // Necessarily closed polyhedra are trivially closed.
   if (is_necessarily_closed()) {
     return;
   }
   // Any empty or zero-dimensional polyhedron is closed.
   if (marked_empty() || space_dim == 0) {
     return;
   }
 
   // The computation can be done using constraints or generators.
   // If we use constraints, we will change them, so that having pending
   // constraints would be useless. If we use generators, we add generators,
   // so that having pending generators still makes sense.
 
   // Process any pending constraints.
   if (has_pending_constraints() && !process_pending_constraints()) {
     return;
   }
 
   // Use constraints only if they are available and
   // there are no pending generators.
   if (!has_pending_generators() && constraints_are_up_to_date()) {
     bool changed = false;
 
     // Transform all strict inequalities into non-strict ones.
     for (dimension_type i = con_sys.num_rows(); i-- > 0; ) {
       Constraint& c = con_sys.sys.rows[i];
       if (c.epsilon_coefficient() < 0 && !c.is_tautological()) {
         c.set_epsilon_coefficient(0);
         // Enforce normalization.
         c.expr.normalize();
         PPL_ASSERT(c.OK());
         changed = true;
       }
     }
 
     PPL_ASSERT(con_sys.sys.OK());
 
     if (changed) {
       con_sys.insert(Constraint::epsilon_leq_one());
       con_sys.set_sorted(false);
       // After changing the system of constraints, the generators
       // are no longer up-to-date and the constraints are no longer
       // minimized.
       clear_generators_up_to_date();
       clear_constraints_minimized();
     }
   }
   else {
     // Here we use generators, possibly keeping constraints.
     PPL_ASSERT(generators_are_up_to_date());
     // Add the corresponding point to each closure point.
     gen_sys.add_corresponding_points();
     if (can_have_something_pending()) {
       set_generators_pending();
     }
     else {
       // We cannot have pending generators; this also implies
       // that generators may have lost their sortedness.
       gen_sys.unset_pending_rows();
       gen_sys.set_sorted(false);
       // Constraints are not up-to-date and generators are not minimized.
       clear_constraints_up_to_date();
       clear_generators_minimized();
     }
   }
   PPL_ASSERT_HEAVY(OK());
 }

Topology Parma_Polyhedra_Library::Polyhedron::topology ( ) const

inlineprivate

Returns the topological kind of the polyhedron.

Definition at line 62 of file Polyhedron_inlines.hh.

References con_sys, and Parma_Polyhedra_Library::Constraint_System::topology().

Referenced by add_space_dimensions_and_embed(), affine_form_image(), BFT00_poly_hull_assign_if_exact(), BHRZ03_combining_constraints(), BHRZ03_evolving_points(), BHRZ03_evolving_rays(), BHRZ03_widening_assign(), BHZ09_poly_hull_assign_if_exact(), concatenate_assign(), contains(), H79_widening_assign(), intersection_assign(), is_included_in(), m_swap(), map_space_dimensions(), operator=(), operator==(), poly_difference_assign(), poly_hull_assign(), Polyhedron(), quick_equivalence_test(), select_CH78_constraints(), select_H79_constraints(), simplify_using_context_assign(), and time_elapse_assign().

                            {
   // We can check either one of the two matrices.
   // (`con_sys' is slightly better, since it is placed at offset 0.)
   return con_sys.topology();
 }

memory_size_type Parma_Polyhedra_Library::Polyhedron::total_memory_in_bytes ( ) const

inline

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

Definition at line 35 of file Polyhedron_inlines.hh.

References external_memory_in_bytes().

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

void Parma_Polyhedra_Library::Polyhedron::unconstrain ( Variable var )

Computes the cylindrification of *this with respect to space dimension var, assigning the result to *this.

Parameters

var	The space dimension that will be unconstrained.

Exceptions

std::invalid_argument Thrown if var is not a space dimension of *this.

Definition at line 1910 of file Polyhedron_public.cc.

References Parma_Polyhedra_Library::Generator::line(), and Parma_Polyhedra_Library::Variable::space_dimension().

                                              {
   // Dimension-compatibility check.
   if (space_dim < var.space_dimension()) {
     throw_dimension_incompatible("unconstrain(var)", var.space_dimension());
   }
   // Do something only if the polyhedron is non-empty.
   if (marked_empty()
       || (has_pending_constraints() && !process_pending_constraints())
       || (!generators_are_up_to_date() && !update_generators())) {
     // Empty: do nothing.
     return;
   }
 
   PPL_ASSERT(generators_are_up_to_date());
   // Since `gen_sys' is not empty, the topology and space dimension
   // of the inserted generator are automatically adjusted.
   if (can_have_something_pending()) {
     gen_sys.insert_pending(Generator::line(var));
     set_generators_pending();
   }
   else {
     gen_sys.insert(Generator::line(var));
     // After adding the new generator,
     // constraints are no longer up-to-date.
     clear_generators_minimized();
     clear_constraints_up_to_date();
   }
   PPL_ASSERT_HEAVY(OK(true));
 }

void Parma_Polyhedra_Library::Polyhedron::unconstrain ( const Variables_Set & vars )

Computes the cylindrification of *this with respect to the set of space dimensions vars, assigning the result to *this.

Parameters

vars	The set of space dimension that will be unconstrained.

Exceptions

std::invalid_argument Thrown if *this is dimension-incompatible with one of the Variable objects contained in vars.

Definition at line 1941 of file Polyhedron_public.cc.

References Parma_Polyhedra_Library::Generator::line(), and Parma_Polyhedra_Library::Variables_Set::space_dimension().

                                                     {
   // The cylindrification with respect to no dimensions is a no-op.
   // This case also captures the only legal cylindrification
   // of a polyhedron in a 0-dim space.
   if (vars.empty()) {
     return;
   }
   // Dimension-compatibility check.
   const dimension_type min_space_dim = vars.space_dimension();
   if (space_dim < min_space_dim) {
     throw_dimension_incompatible("unconstrain(vs)", min_space_dim);
   }
 
   // Do something only if the polyhedron is non-empty.
   if (marked_empty()
       || (has_pending_constraints() && !process_pending_constraints())
       || (!generators_are_up_to_date() && !update_generators())) {
     // Empty: do nothing.
     return;
   }
 
   PPL_ASSERT(generators_are_up_to_date());
   // Since `gen_sys' is not empty, the topology and space dimension
   // of the inserted generators are automatically adjusted.
   Variables_Set::const_iterator vsi = vars.begin();
   Variables_Set::const_iterator vsi_end = vars.end();
   if (can_have_something_pending()) {
     for ( ; vsi != vsi_end; ++vsi) {
       gen_sys.insert_pending(Generator::line(Variable(*vsi)));
     }
     set_generators_pending();
   }
   else {
     for ( ; vsi != vsi_end; ++vsi) {
       gen_sys.insert(Generator::line(Variable(*vsi)));
     }
     // After adding the new generators,
     // constraints are no longer up-to-date.
     clear_generators_minimized();
     clear_constraints_up_to_date();
   }
   PPL_ASSERT_HEAVY(OK(true));
 }

void Parma_Polyhedra_Library::Polyhedron::update_constraints ( ) const

private

Updates constraints starting from generators and minimizes them.

The resulting system of constraints is only partially sorted: the equalities are in the upper part of the matrix, while the inequalities in the lower part.

Definition at line 859 of file Polyhedron_nonpublic.cc.

References clear_sat_g_up_to_date(), con_sys, gen_sys, sat_c, set_constraints_minimized(), set_generators_minimized(), and set_sat_c_up_to_date().

Referenced by H79_widening_assign(), intersection_assign(), and is_included_in().

                                         {
   PPL_ASSERT(space_dim > 0);
   PPL_ASSERT(!marked_empty());
   PPL_ASSERT(generators_are_up_to_date());
   // We assume the polyhedron has no pending constraints or generators.
   PPL_ASSERT(!has_something_pending());
 
   Polyhedron& x = const_cast<Polyhedron&>(*this);
   minimize(false, x.gen_sys, x.con_sys, x.sat_c);
   // `sat_c' is the only saturation matrix up-to-date.
   x.set_sat_c_up_to_date();
   x.clear_sat_g_up_to_date();
   // The system of constraints and the system of generators
   // are minimized.
   x.set_constraints_minimized();
   x.set_generators_minimized();
 }

bool Parma_Polyhedra_Library::Polyhedron::update_generators ( ) const

private

Updates generators starting from constraints and minimizes them.

Returns: false if and only if *this turns out to be an empty polyhedron.

The resulting system of generators is only partially sorted: the lines are in the upper part of the matrix, while rays and points are in the lower part. It is illegal to call this method when the Status field already declares the polyhedron to be empty.

Definition at line 878 of file Polyhedron_nonpublic.cc.

References clear_sat_c_up_to_date(), con_sys, Parma_Polyhedra_Library::Implementation::BD_Shapes::empty, gen_sys, sat_g, set_constraints_minimized(), set_empty(), set_generators_minimized(), and set_sat_g_up_to_date().

Referenced by limited_BHRZ03_extrapolation_assign(), limited_H79_extrapolation_assign(), map_space_dimensions(), poly_hull_assign(), positive_time_elapse_assign_impl(), select_H79_constraints(), and time_elapse_assign().

                                        {
   PPL_ASSERT(space_dim > 0);
   PPL_ASSERT(!marked_empty());
   PPL_ASSERT(constraints_are_up_to_date());
   // We assume the polyhedron has no pending constraints or generators.
   PPL_ASSERT(!has_something_pending());
 
   Polyhedron& x = const_cast<Polyhedron&>(*this);
   // If the system of constraints is not consistent the
   // polyhedron is empty.
   const bool empty = minimize(true, x.con_sys, x.gen_sys, x.sat_g);
   if (empty) {
     x.set_empty();
   }
   else {
     // `sat_g' is the only saturation matrix up-to-date.
     x.set_sat_g_up_to_date();
     x.clear_sat_c_up_to_date();
     // The system of constraints and the system of generators
     // are minimized.
     x.set_constraints_minimized();
     x.set_generators_minimized();
   }
   return !empty;
 }

void Parma_Polyhedra_Library::Polyhedron::update_sat_c ( ) const

private

Updates sat_c using the updated constraints and generators.

It is assumed that constraints and generators are up-to-date and minimized and that the Status field does not already flag sat_c to be up-to-date. The values of the saturation matrix are computed as follows:

$\begin{cases} sat\_c[i][j] = 0, \quad \text{if } G[i] \cdot C^\mathrm{T}[j] = 0; \\ sat\_c[i][j] = 1, \quad \text{if } G[i] \cdot C^\mathrm{T}[j] > 0. \end{cases}$

Definition at line 905 of file Polyhedron_nonpublic.cc.

References Parma_Polyhedra_Library::Bit_Matrix::clear(), Parma_Polyhedra_Library::Bit_Matrix::resize(), sat_c, set_sat_c_up_to_date(), and Parma_Polyhedra_Library::Scalar_Products::sign().

Referenced by add_space_dimensions_and_embed(), and obtain_sorted_constraints_with_sat_c().

                                   {
   PPL_ASSERT(constraints_are_minimized());
   PPL_ASSERT(generators_are_minimized());
   PPL_ASSERT(!sat_c_is_up_to_date());
 
   // We only consider non-pending rows.
   const dimension_type csr = con_sys.first_pending_row();
   const dimension_type gsr = gen_sys.first_pending_row();
   Polyhedron& x = const_cast<Polyhedron&>(*this);
 
   // The columns of `sat_c' represent the constraints and
   // its rows represent the generators: resize accordingly.
   x.sat_c.resize(gsr, csr);
   for (dimension_type i = gsr; i-- > 0; ) {
     for (dimension_type j = csr; j-- > 0; ) {
       const int sp_sign = Scalar_Products::sign(con_sys[j], gen_sys[i]);
       // The negativity of this scalar product would mean
       // that the generator `gen_sys[i]' violates the constraint
       // `con_sys[j]' and it is not possible because both generators
       // and constraints are up-to-date.
       PPL_ASSERT(sp_sign >= 0);
       if (sp_sign > 0) {
         // `gen_sys[i]' satisfies (without saturate) `con_sys[j]'.
         x.sat_c[i].set(j);
       }
       else {
         // `gen_sys[i]' saturates `con_sys[j]'.
         x.sat_c[i].clear(j);
       }
     }
   }
   x.set_sat_c_up_to_date();
 }

void Parma_Polyhedra_Library::Polyhedron::update_sat_g ( ) const

private

Updates sat_g using the updated constraints and generators.

It is assumed that constraints and generators are up-to-date and minimized and that the Status field does not already flag sat_g to be up-to-date. The values of the saturation matrix are computed as follows:

$\begin{cases} sat\_g[i][j] = 0, \quad \text{if } C[i] \cdot G^\mathrm{T}[j] = 0; \\ sat\_g[i][j] = 1, \quad \text{if } C[i] \cdot G^\mathrm{T}[j] > 0. \end{cases}$

Definition at line 940 of file Polyhedron_nonpublic.cc.

References Parma_Polyhedra_Library::Bit_Matrix::clear(), Parma_Polyhedra_Library::Bit_Matrix::resize(), sat_g, set_sat_g_up_to_date(), and Parma_Polyhedra_Library::Scalar_Products::sign().

Referenced by BHZ09_C_poly_hull_assign_if_exact(), BHZ09_NNC_poly_hull_assign_if_exact(), obtain_sorted_generators_with_sat_g(), and select_H79_constraints().

                                   {
   PPL_ASSERT(constraints_are_minimized());
   PPL_ASSERT(generators_are_minimized());
   PPL_ASSERT(!sat_g_is_up_to_date());
 
   // We only consider non-pending rows.
   const dimension_type csr = con_sys.first_pending_row();
   const dimension_type gsr = gen_sys.first_pending_row();
   Polyhedron& x = const_cast<Polyhedron&>(*this);
 
   // The columns of `sat_g' represent generators and its
   // rows represent the constraints: resize accordingly.
   x.sat_g.resize(csr, gsr);
   for (dimension_type i = csr; i-- > 0; ) {
     for (dimension_type j = gsr; j-- > 0; ) {
       const int sp_sign = Scalar_Products::sign(con_sys[i], gen_sys[j]);
       // The negativity of this scalar product would mean
       // that the generator `gen_sys[j]' violates the constraint
       // `con_sys[i]' and it is not possible because both generators
       // and constraints are up-to-date.
       PPL_ASSERT(sp_sign >= 0);
       if (sp_sign > 0) {
         // `gen_sys[j]' satisfies (without saturate) `con_sys[i]'.
         x.sat_g[i].set(j);
       }
       else {
         // `gen_sys[j]' saturates `con_sys[i]'.
         x.sat_g[i].clear(j);
       }
     }
   }
   x.set_sat_g_up_to_date();
 }

void Parma_Polyhedra_Library::Polyhedron::upper_bound_assign ( const Polyhedron & y )

inline

Same as poly_hull_assign(y).

Definition at line 81 of file Polyhedron_inlines.hh.

References poly_hull_assign().

Referenced by BHZ09_poly_hull_assign_if_exact().

                                                   {
   poly_hull_assign(y);
 }

void Parma_Polyhedra_Library::Polyhedron::widening_assign	(	const Polyhedron &	y,
		unsigned *	tp = `0`
	)

inline

Same as H79_widening_assign(y, tp).

Definition at line 91 of file Polyhedron_inlines.hh.

References H79_widening_assign().

                                                              {
   H79_widening_assign(y, tp);
 }

void Parma_Polyhedra_Library::Polyhedron::wrap_assign	(	const Variables_Set &	vars,
		Bounded_Integer_Type_Width	w,
		Bounded_Integer_Type_Representation	r,
		Bounded_Integer_Type_Overflow	o,
		const Constraint_System *	cs_p = `0`,
		unsigned	complexity_threshold = `16`,
		bool	wrap_individually = `true`
	)

Wraps the specified dimensions of the vector space.

Parameters

vars	The set of Variable objects corresponding to the space dimensions to be wrapped.
w	The width of the bounded integer type corresponding to all the dimensions to be wrapped.
r	The representation of the bounded integer type corresponding to all the dimensions to be wrapped.
o	The overflow behavior of the bounded integer type corresponding to all the dimensions to be wrapped.
cs_p	Possibly null pointer to a constraint system whose variables are contained in `vars`. If `cs_p` depends on variables not in `vars`, the behavior is undefined. When non-null, the pointed-to constraint system is assumed to represent the conditional or looping construct guard with respect to which wrapping is performed. Since wrapping requires the computation of upper bounds and due to non-distributivity of constraint refinement over upper bounds, passing a constraint system in this way can be more precise than refining the result of the wrapping operation with the constraints in `cs_p`.
complexity_threshold	A precision parameter of the wrapping operator: higher values result in possibly improved precision.
wrap_individually	`true` if the dimensions should be wrapped individually (something that results in much greater efficiency to the detriment of precision).

Exceptions

std::invalid_argument Thrown if *cs_p is dimension-incompatible with vars, or if *this is dimension-incompatible vars or with *cs_p.

Definition at line 4058 of file Polyhedron_public.cc.

References Parma_Polyhedra_Library::Implementation::wrap_assign().

                                                      {
   if (is_necessarily_closed()) {
     Implementation::wrap_assign(static_cast<C_Polyhedron&>(*this),
                                 vars, w, r, o, cs_p,
                                 complexity_threshold, wrap_individually,
                                 "C_Polyhedron");
   }
   else {
     Implementation::wrap_assign(static_cast<NNC_Polyhedron&>(*this),
                                 vars, w, r, o, cs_p,
                                 complexity_threshold, wrap_individually,
                                 "NNC_Polyhedron");
   }
 }

Friends And Related Function Documentation

bool operator!=	(	const Polyhedron &	x,
		const Polyhedron &	y
	)

Note that x and y may be topology- and/or dimension-incompatible polyhedra: in those cases, the value true is returned.

bool operator!=	(	const Polyhedron &	x,
		const Polyhedron &	y
	)

                                                      {
   return !(x == y);
 }

std::ostream & operator<<	(	std::ostream &	s,
		const Polyhedron &	ph
	)

Writes a textual representation of ph on s: false is written if ph is an empty polyhedron; true is written if ph is a universe polyhedron; a minimized system of constraints defining ph is written otherwise, all constraints in one row separated by ", ".

std::ostream & operator<<	(	std::ostream &	s,
		const Polyhedron &	ph
	)

References is_empty(), and minimized_constraints().

                                                                {
   if (ph.is_empty()) {
     s << "false";
   }
   else {
     s << ph.minimized_constraints();
   }
   return s;
 }

bool operator==	(	const Polyhedron &	x,
		const Polyhedron &	y
	)

Note that x and y may be topology- and/or dimension-incompatible polyhedra: in those cases, the value false is returned.

bool operator==	(	const Polyhedron &	x,
		const Polyhedron &	y
	)

friend

bool operator==	(	const Polyhedron &	x,
		const Polyhedron &	y
	)

References is_empty(), is_included_in(), marked_empty(), quick_equivalence_test(), space_dim, topology(), TVB_FALSE, and TVB_TRUE.

                                                         {
   // If the two polyhedra are topology-incompatible or dimension-incompatible,
   // then they cannot be the same polyhedron.
   if (x.topology() != y.topology() || x.space_dim != y.space_dim) {
     return false;
   }
 
   if (x.marked_empty()) {
     return y.is_empty();
   }
   else if (y.marked_empty()) {
     return x.is_empty();
   }
   else if (x.space_dim == 0) {
     return true;
   }
 
   switch (x.quick_equivalence_test(y)) {
   case Polyhedron::TVB_TRUE:
     return true;
   case Polyhedron::TVB_FALSE:
     return false;
   default:
     if (x.is_included_in(y)) {
       if (x.marked_empty()) {
         return y.is_empty();
       }
       else {
         return y.is_included_in(x);
       }
     }
     else {
       return false;
     }
   }
 }

template<typename T >

friend class Parma_Polyhedra_Library::BD_Shape

friend

Definition at line 2621 of file Polyhedron_defs.hh.

friend class Parma_Polyhedra_Library::BHRZ03_Certificate

friend

Definition at line 2624 of file Polyhedron_defs.hh.

template<typename Interval >

friend class Parma_Polyhedra_Library::Box

friend

Definition at line 2620 of file Polyhedron_defs.hh.

friend class Parma_Polyhedra_Library::Grid

friend

Definition at line 2623 of file Polyhedron_defs.hh.

friend class Parma_Polyhedra_Library::H79_Certificate

friend

Definition at line 2625 of file Polyhedron_defs.hh.

bool Parma_Polyhedra_Library::Interfaces::is_necessarily_closed_for_interfaces ( const Polyhedron & )

friend

template<typename T >

friend class Parma_Polyhedra_Library::Octagonal_Shape

friend

Definition at line 2622 of file Polyhedron_defs.hh.

template<typename PH >

bool poly_hull_assign_if_exact	(	PH &	p,
		const PH &	q
	)

template<typename PH >

bool poly_hull_assign_if_exact	(	PH &	p,
		const PH &	q
	)

References Parma_Polyhedra_Library::Powerset< Parma_Polyhedra_Library::Determinate< PSET > >::begin(), contains(), and Parma_Polyhedra_Library::Powerset< Parma_Polyhedra_Library::Determinate< PSET > >::end().

                                               {
   PH poly_hull = p;
   NNC_Polyhedron nnc_p(p);
   poly_hull.poly_hull_assign(q);
   std::pair<PH, Pointset_Powerset<NNC_Polyhedron> >
     partition = linear_partition(q, poly_hull);
   const Pointset_Powerset<NNC_Polyhedron>& s = partition.second;
   typedef Pointset_Powerset<NNC_Polyhedron>::const_iterator iter;
   for (iter i = s.begin(), s_end = s.end(); i != s_end; ++i) {
     // The polyhedral hull is exact if and only if all the elements
     // of the partition of the polyhedral hull of `p' and `q' with
     // respect to `q' are included in `p'
     if (!nnc_p.contains(i->pointset())) {
       return false;
     }
   }
   p = poly_hull;
   return true;
 }

void swap	(	Polyhedron &	x,
		Polyhedron &	y
	)

Referenced by add_space_dimensions(), conversion(), m_swap(), Polyhedron(), and simplify().

void swap	(	Polyhedron &	x,
		Polyhedron &	y
	)

References m_swap().

                                    {
   x.m_swap(y);
 }

Member Data Documentation

Constraint_System Parma_Polyhedra_Library::Polyhedron::con_sys

private

The system of constraints.

Definition at line 2030 of file Polyhedron_defs.hh.

Referenced by add_space_dimensions_and_embed(), Parma_Polyhedra_Library::BD_Shape< T >::BD_Shape(), BFT00_poly_hull_assign_if_exact(), BHRZ03_combining_constraints(), BHZ09_C_poly_hull_assign_if_exact(), BHZ09_NNC_poly_hull_assign_if_exact(), H79_widening_assign(), intersection_assign(), is_included_in(), is_necessarily_closed(), m_swap(), map_space_dimensions(), obtain_sorted_constraints(), obtain_sorted_constraints_with_sat_c(), Parma_Polyhedra_Library::Octagonal_Shape< T >::Octagonal_Shape(), operator=(), Polyhedron(), process_pending_constraints(), process_pending_generators(), quick_equivalence_test(), remove_pending_to_obtain_constraints(), select_CH78_constraints(), select_H79_constraints(), simplified_constraints(), simplify_using_context_assign(), strongly_minimize_constraints(), topology(), update_constraints(), and update_generators().

const Representation Parma_Polyhedra_Library::Polyhedron::default_con_sys_repr = DENSE

staticprivate

Definition at line 2026 of file Polyhedron_defs.hh.

const Representation Parma_Polyhedra_Library::Polyhedron::default_gen_sys_repr = DENSE

staticprivate

Definition at line 2027 of file Polyhedron_defs.hh.

Generator_System Parma_Polyhedra_Library::Polyhedron::gen_sys

private

Bit_Matrix Parma_Polyhedra_Library::Polyhedron::sat_c

private

The saturation matrix having constraints on its columns.

Definition at line 2036 of file Polyhedron_defs.hh.

Referenced by add_space_dimensions_and_embed(), m_swap(), obtain_sorted_constraints(), obtain_sorted_constraints_with_sat_c(), obtain_sorted_generators(), obtain_sorted_generators_with_sat_g(), operator=(), Polyhedron(), process_pending_constraints(), process_pending_generators(), strongly_minimize_generators(), update_constraints(), and update_sat_c().

Bit_Matrix Parma_Polyhedra_Library::Polyhedron::sat_g

private

The saturation matrix having generators on its columns.

Definition at line 2039 of file Polyhedron_defs.hh.

Referenced by add_space_dimensions_and_embed(), BHZ09_C_poly_hull_assign_if_exact(), BHZ09_NNC_poly_hull_assign_if_exact(), m_swap(), obtain_sorted_constraints(), obtain_sorted_constraints_with_sat_c(), obtain_sorted_generators(), obtain_sorted_generators_with_sat_g(), operator=(), Polyhedron(), process_pending_constraints(), process_pending_generators(), select_H79_constraints(), strongly_minimize_constraints(), update_generators(), and update_sat_g().

PPL::dimension_type * Parma_Polyhedra_Library::Polyhedron::simplify_num_saturators_p = 0

staticprivate

Pointer to an array used by simplify().

Holds (between class initialization and finalization) a pointer to an array, allocated with operator new[](), of simplify_num_saturators_size elements.

Definition at line 2610 of file Polyhedron_defs.hh.

Referenced by initialize(), and simplify().

size_t Parma_Polyhedra_Library::Polyhedron::simplify_num_saturators_size = 0

staticprivate

Dimension of an array used by simplify().

Holds (between class initialization and finalization) the size of the array pointed to by simplify_num_saturators_p.

Definition at line 2618 of file Polyhedron_defs.hh.

Referenced by initialize(), and simplify().

dimension_type Parma_Polyhedra_Library::Polyhedron::space_dim

private

The number of dimensions of the enclosing vector space.

Definition at line 2049 of file Polyhedron_defs.hh.

Referenced by add_space_dimensions_and_embed(), affine_form_image(), BFT00_poly_hull_assign_if_exact(), BHRZ03_combining_constraints(), BHRZ03_evolving_points(), BHRZ03_evolving_rays(), BHRZ03_widening_assign(), BHZ09_C_poly_hull_assign_if_exact(), BHZ09_NNC_poly_hull_assign_if_exact(), BHZ09_poly_hull_assign_if_exact(), Parma_Polyhedra_Library::BHRZ03_Certificate::compare(), concatenate_assign(), contains(), H79_widening_assign(), intersection_assign(), is_included_in(), limited_BHRZ03_extrapolation_assign(), limited_H79_extrapolation_assign(), m_swap(), map_space_dimensions(), operator=(), operator==(), poly_difference_assign(), poly_hull_assign(), Polyhedron(), positive_time_elapse_assign_impl(), process_pending(), quick_equivalence_test(), refine_with_linear_form_inequality(), select_CH78_constraints(), select_H79_constraints(), simplify_using_context_assign(), space_dimension(), strongly_minimize_constraints(), strongly_minimize_generators(), and time_elapse_assign().

Status Parma_Polyhedra_Library::Polyhedron::status

private

The status flags to keep track of the polyhedron's internal state.

Definition at line 2046 of file Polyhedron_defs.hh.

Referenced by add_space_dimensions_and_embed(), clear_constraints_minimized(), clear_constraints_up_to_date(), clear_empty(), clear_generators_minimized(), clear_generators_up_to_date(), clear_pending_constraints(), clear_pending_generators(), clear_sat_c_up_to_date(), clear_sat_g_up_to_date(), constraints_are_minimized(), constraints_are_up_to_date(), generators_are_minimized(), generators_are_up_to_date(), has_pending_constraints(), has_pending_generators(), has_something_pending(), m_swap(), marked_empty(), operator=(), Polyhedron(), sat_c_is_up_to_date(), sat_g_is_up_to_date(), set_constraints_minimized(), set_constraints_pending(), set_constraints_up_to_date(), set_generators_minimized(), set_generators_pending(), set_generators_up_to_date(), set_sat_c_up_to_date(), and set_sat_g_up_to_date().

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

Classes

Public Types

Public Member Functions

Static Public Member Functions

Protected Member Functions

Static Protected Member Functions

Private Types

Private Member Functions

Static Private Member Functions

Private Attributes

Static Private Attributes

Friends

Related Functions

Widening- and Extrapolation-Related Functions

Exception Throwers

Detailed Description

Member Typedef Documentation

Constructor & Destructor Documentation

Member Function Documentation

Friends And Related Function Documentation

Member Data Documentation