| PPL
    1.2
    | 
The base class for convex polyhedra. More...
#include <ppl.hh>

| Public Types | |
| typedef Coefficient | coefficient_type | 
| The numeric type of coefficients. | |
| Public Member Functions | |
| Member Functions that Do Not Modify the Polyhedron | |
| dimension_type | space_dimension () const | 
| Returns the dimension of the vector space enclosing *this. | |
| dimension_type | affine_dimension () const | 
| Returns  , if *thisis empty; otherwise, returns the affine dimension of*this. | |
| const Constraint_System & | constraints () const | 
| Returns the system of constraints. | |
| const Constraint_System & | minimized_constraints () const | 
| Returns the system of constraints, with no redundant constraint. | |
| const Generator_System & | generators () const | 
| Returns the system of generators. | |
| const Generator_System & | minimized_generators () const | 
| Returns the system of generators, with no redundant generator. | |
| Congruence_System | congruences () const | 
| Returns a system of (equality) congruences satisfied by *this. | |
| 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. | |
| Poly_Con_Relation | relation_with (const Constraint &c) const | 
| Returns the relations holding between the polyhedron *thisand the constraintc.  More... | |
| Poly_Gen_Relation | relation_with (const Generator &g) const | 
| Returns the relations holding between the polyhedron *thisand the generatorg.  More... | |
| Poly_Con_Relation | relation_with (const Congruence &cg) const | 
| Returns the relations holding between the polyhedron *thisand the congruencec.  More... | |
| bool | is_empty () const | 
| Returns trueif and only if*thisis an empty polyhedron. | |
| bool | is_universe () const | 
| Returns trueif and only if*thisis a universe polyhedron. | |
| bool | is_topologically_closed () const | 
| Returns trueif and only if*thisis a topologically closed subset of the vector space. | |
| bool | is_disjoint_from (const Polyhedron &y) const | 
| Returns trueif and only if*thisandyare disjoint.  More... | |
| bool | is_discrete () const | 
| Returns trueif and only if*thisis discrete. | |
| bool | is_bounded () const | 
| Returns trueif and only if*thisis a bounded polyhedron. | |
| bool | contains_integer_point () const | 
| Returns trueif and only if*thiscontains at least one integer point. | |
| bool | constrains (Variable var) const | 
| Returns trueif and only ifvaris constrained in*this.  More... | |
| bool | bounds_from_above (const Linear_Expression &expr) const | 
| Returns trueif and only ifexpris bounded from above in*this.  More... | |
| bool | bounds_from_below (const Linear_Expression &expr) const | 
| Returns trueif and only ifexpris bounded from below in*this.  More... | |
| bool | maximize (const Linear_Expression &expr, Coefficient &sup_n, Coefficient &sup_d, bool &maximum) const | 
| Returns trueif and only if*thisis not empty andexpris 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 trueif and only if*thisis not empty andexpris bounded from above in*this, in which case the supremum value and a point whereexprreaches it are computed.  More... | |
| bool | minimize (const Linear_Expression &expr, Coefficient &inf_n, Coefficient &inf_d, bool &minimum) const | 
| Returns trueif and only if*thisis not empty andexpris 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 trueif and only if*thisis not empty andexpris bounded from below in*this, in which case the infimum value and a point whereexprreaches it are computed.  More... | |
| bool | frequency (const Linear_Expression &expr, Coefficient &freq_n, Coefficient &freq_d, Coefficient &val_n, Coefficient &val_d) const | 
| Returns trueif and only if there exist a unique valuevalsuch that*thissaturates the equalityexpr = val.  More... | |
| bool | contains (const Polyhedron &y) const | 
| Returns trueif and only if*thiscontainsy.  More... | |
| bool | strictly_contains (const Polyhedron &y) const | 
| Returns trueif and only if*thisstrictly containsy.  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 cto the system of constraints of*this(without minimizing the result).  More... | |
| void | add_generator (const Generator &g) | 
| Adds a copy of generator gto the system of generators of*this(without minimizing the result).  More... | |
| void | add_congruence (const Congruence &cg) | 
| Adds a copy of congruence cgto*this, ifcgcan be exactly represented by a polyhedron.  More... | |
| void | add_constraints (const Constraint_System &cs) | 
| Adds a copy of the constraints in csto the system of constraints of*this(without minimizing the result).  More... | |
| void | add_recycled_constraints (Constraint_System &cs) | 
| Adds the constraints in csto 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 gsto the system of generators of*this(without minimizing the result).  More... | |
| void | add_recycled_generators (Generator_System &gs) | 
| Adds the generators in gsto 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 cgsto*this, if all the congruences can be exactly represented by a polyhedron.  More... | |
| void | add_recycled_congruences (Congruence_System &cgs) | 
| Adds the congruences in cgsto*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 cto refine*this.  More... | |
| void | refine_with_congruence (const Congruence &cg) | 
| Uses a copy of congruence cgto refine*this.  More... | |
| void | refine_with_constraints (const Constraint_System &cs) | 
| Uses a copy of the constraints in csto refine*this.  More... | |
| void | refine_with_congruences (const Congruence_System &cgs) | 
| Uses a copy of the congruences in cgsto 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 *thiswith the constraint expressed byleft  rightifis_strictis set, with the constraintleft  rightotherwise.  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 *thiswith the constraint expressed byleft  right, where 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 storewith the constraints defining*this.  More... | |
| void | unconstrain (Variable var) | 
| Computes the cylindrification of *thiswith respect to space dimensionvar, assigning the result to*this.  More... | |
| void | unconstrain (const Variables_Set &vars) | 
| Computes the cylindrification of *thiswith respect to the set of space dimensionsvars, assigning the result to*this.  More... | |
| void | intersection_assign (const Polyhedron &y) | 
| Assigns to *thisthe intersection of*thisandy.  More... | |
| void | poly_hull_assign (const Polyhedron &y) | 
| Assigns to *thisthe poly-hull of*thisandy.  More... | |
| void | upper_bound_assign (const Polyhedron &y) | 
| Same as poly_hull_assign(y). | |
| void | poly_difference_assign (const Polyhedron &y) | 
| Assigns to *thisthe poly-difference of*thisandy.  More... | |
| void | difference_assign (const Polyhedron &y) | 
| Same as poly_difference_assign(y). | |
| bool | simplify_using_context_assign (const Polyhedron &y) | 
| Assigns to *thisa meet-preserving simplification of*thiswith respect toy. Iffalseis 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 *thisthe affine image of*thisunder the function mapping variablevarto the affine expression specified byexpranddenominator.  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 *thisthe affine preimage of*thisunder the function mapping variablevarto the affine expression specified byexpranddenominator.  More... | |
| void | generalized_affine_image (Variable var, Relation_Symbol relsym, const Linear_Expression &expr, Coefficient_traits::const_reference denominator=Coefficient_one()) | 
| Assigns to *thisthe image of*thiswith respect to the generalized affine relation , where  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 *thisthe preimage of*thiswith respect to the generalized affine relation , where  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 *thisthe image of*thiswith respect to the generalized affine relation , where  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 *thisthe preimage of*thiswith respect to the generalized affine relation , where  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 *thisthe image of*thiswith respect to the bounded affine relation .  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 *thisthe preimage of*thiswith respect to the bounded affine relation .  More... | |
| void | time_elapse_assign (const Polyhedron &y) | 
| Assigns to *thisthe result of computing the time-elapse between*thisandy.  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*thisandy.  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 *thisby 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 *thisby dropping some points with non-integer coordinates for the space dimensions corresponding tovars.  More... | |
| void | topological_closure_assign () | 
| Assigns to *thisits topological closure. | |
| void | BHRZ03_widening_assign (const Polyhedron &y, unsigned *tp=0) | 
| Assigns to *thisthe result of computing the BHRZ03-widening between*thisandy.  More... | |
| void | limited_BHRZ03_extrapolation_assign (const Polyhedron &y, const Constraint_System &cs, unsigned *tp=0) | 
| Assigns to *thisthe result of computing the limited extrapolation between*thisandyusing the BHRZ03-widening operator.  More... | |
| void | bounded_BHRZ03_extrapolation_assign (const Polyhedron &y, const Constraint_System &cs, unsigned *tp=0) | 
| Assigns to *thisthe result of computing the bounded extrapolation between*thisandyusing the BHRZ03-widening operator.  More... | |
| void | H79_widening_assign (const Polyhedron &y, unsigned *tp=0) | 
| Assigns to *thisthe result of computing the H79_widening between*thisandy.  More... | |
| void | widening_assign (const Polyhedron &y, unsigned *tp=0) | 
| Same as H79_widening_assign(y, tp). | |
| void | limited_H79_extrapolation_assign (const Polyhedron &y, const Constraint_System &cs, unsigned *tp=0) | 
| Assigns to *thisthe result of computing the limited extrapolation between*thisandyusing the H79-widening operator.  More... | |
| void | bounded_H79_extrapolation_assign (const Polyhedron &y, const Constraint_System &cs, unsigned *tp=0) | 
| Assigns to *thisthe result of computing the bounded extrapolation between*thisandyusing 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 mnew space dimensions and embeds the old polyhedron in the new vector space.  More... | |
| void | add_space_dimensions_and_project (dimension_type m) | 
| Adds mnew space dimensions to the polyhedron and does not embed it in the new vector space.  More... | |
| void | concatenate_assign (const Polyhedron &y) | 
| Assigns to *thisthe concatenation of*thisandy, 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 mcopies of the space dimension corresponding tovar.  More... | |
| void | fold_space_dimensions (const Variables_Set &vars, Variable dest) | 
| Folds the space dimensions in varsintodest.  More... | |
| Miscellaneous Member Functions | |
| ~Polyhedron () | |
| Destructor. | |
| void | m_swap (Polyhedron &y) | 
| Swaps *thiswith polyhedrony. (*thisandycan be dimension-incompatible.)  More... | |
| void | ascii_dump () const | 
| Writes to std::cerran ASCII representation of*this. | |
| void | ascii_dump (std::ostream &s) const | 
| Writes to san ASCII representation of*this. | |
| void | print () const | 
| Prints *thistostd::cerrusingoperator<<. | |
| bool | ascii_load (std::istream &s) | 
| Loads from san ASCII representation (as produced by ascii_dump(std::ostream&) const) and sets*thisaccordingly. Returnstrueif successful,falseotherwise. | |
| memory_size_type | total_memory_in_bytes () const | 
| Returns the total size in bytes of the memory occupied by *this. | |
| memory_size_type | external_memory_in_bytes () const | 
| Returns the size in bytes of the memory managed by *this. | |
| 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. | |
| static bool | can_recycle_constraint_systems () | 
| Returns trueindicating that this domain has methods that can recycle constraints. | |
| static void | initialize () | 
| Initializes the class. | |
| static void | finalize () | 
| Finalizes the class. | |
| static bool | can_recycle_congruence_systems () | 
| Returns falseindicating that this domain cannot recycle congruences. | |
| 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. ( *thisandycan be dimension-incompatible.) | |
| void | drop_some_non_integer_points (const Variables_Set *vars_p, Complexity_Class complexity) | 
| Possibly tightens *thisby 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 *thisis NNC, assigns to*thisthe result of the "positive time-elapse" between*thisandy.  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 resultbecome a Linear_Expression obtained by normalizing the denominators inlf.  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... | |
| Related Functions | |
| (Note that these are not member functions.) | |
| std::ostream & | operator<< (std::ostream &s, const Polyhedron &ph) | 
| Output operator.  More... | |
| void | swap (Polyhedron &x, Polyhedron &y) | 
| Swaps xwithy.  More... | |
| bool | operator== (const Polyhedron &x, const Polyhedron &y) | 
| Returns trueif and only ifxandyare the same polyhedron.  More... | |
| bool | operator!= (const Polyhedron &x, const Polyhedron &y) | 
| Returns trueif and only ifxandyare different polyhedra.  More... | |
| void | swap (Polyhedron &x, Polyhedron &y) | 
| bool | operator!= (const Polyhedron &x, const Polyhedron &y) | 
The base class for convex polyhedra.
An object of the class Polyhedron represents a convex polyhedron in the vector space  .
.
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  of the enclosing vector space):
 of the enclosing vector space):
Note that four different polyhedra can be defined on the zero-dimension space: the empty polyhedron, either closed or NNC, and the universe polyhedron  , again either closed or NNC.
, again either closed or NNC.
x and y are defined (where they are used) as follows:  , given as a system of constraints:
, given as a system of constraints:  , given as a system of constraints:
, given as a system of constraints:  :
:  and inserting the appropriate generators (a point, a ray and a line).
 and inserting the appropriate generators (a point, a ray and a line). add_space_dimensions_and_embed:  . Then we add a single equality constraint, thus obtaining the polyhedron corresponding to the singleton set
. Then we add a single equality constraint, thus obtaining the polyhedron corresponding to the singleton set  . After the last line of code, the resulting polyhedron is
. After the last line of code, the resulting polyhedron is 
![\[ \bigl\{\, (2, y)^\transpose \in \Rset^2 \bigm| y \in \Rset \,\bigr\}. \]](form_571.png) 
add_space_dimensions_and_project: add_space_dimensions_and_embed. After the last line of code, the resulting polyhedron is the singleton set  .
.affine_image:  , the considered variable is
, the considered variable is  and the affine expression 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
. The resulting polyhedron is the same square translated to the right. Moreover, if the affine transformation for the same variable x is  :
:  . Instead, if we do not use an invertible transformation for the same variable; for example, the affine expression
. Instead, if we do not use an invertible transformation for the same variable; for example, the affine expression  :
: affine_preimage: 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  
  . Instead, if we do not use an invertible transformation for the same variable
. Instead, if we do not use an invertible transformation for the same variable x, for example, the affine expression  :
:  axis.
 axis.remove_space_dimensions:  , while the resulting polyhedron is
, while the resulting polyhedron is  . Be careful when removing space dimensions incrementally: since dimensions are automatically renamed after each application of the
. 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:  : when removing the set of dimensions
: when removing the set of dimensions vars2 we are actually removing variable  of the original polyhedron. For the same reason, the operator
 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. | 
 | protected | 
Builds a polyhedron having the specified properties.
| 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. | 
| 
 | protected | 
Ordinary copy constructor.
The complexity argument is ignored.
| 
 | protected | 
Builds a polyhedron from a system of constraints.
The polyhedron inherits the space dimension of the constraint system.
| topol | The topology of the polyhedron; | 
| cs | The system of constraints defining the polyhedron. | 
| std::invalid_argument | Thrown if the topology of csis incompatible withtopol. | 
| 
 | protected | 
Builds a polyhedron recycling a system of constraints.
The polyhedron inherits the space dimension of the constraint system.
| topol | The topology of the polyhedron; | 
| cs | The system of constraints defining the polyhedron. It is not declared constbecause its data-structures may be recycled to build the polyhedron. | 
| dummy | A dummy tag to syntactically differentiate this one from the other constructors. | 
| std::invalid_argument | Thrown if the topology of csis incompatible withtopol. | 
| 
 | protected | 
Builds a polyhedron from a system of generators.
The polyhedron inherits the space dimension of the generator system.
| topol | The topology of the polyhedron; | 
| gs | The system of generators defining the polyhedron. | 
| std::invalid_argument | Thrown if the topology of gsis incompatible withtopol, or if the system of generators is not empty but has no points. | 
| 
 | protected | 
Builds a polyhedron recycling a system of generators.
The polyhedron inherits the space dimension of the generator system.
| topol | The topology of the polyhedron; | 
| gs | The system of generators defining the polyhedron. It is not declared constbecause its data-structures may be recycled to build the polyhedron. | 
| dummy | A dummy tag to syntactically differentiate this one from the other constructors. | 
| std::invalid_argument | Thrown if the topology of gsis incompatible withtopol, or if the system of generators is not empty but has no points. | 
| 
 | 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.
| topol | The topology of the polyhedron; | 
| box | The box representing the polyhedron to be built; | 
| complexity | This argument is ignored. | 
| 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. 
| std::invalid_argument | Thrown if *thisand constraintcare dimension-incompatible. | 
| 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. 
| std::invalid_argument | Thrown if *thisand generatorgare dimension-incompatible. | 
| 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. 
| std::invalid_argument | Thrown if *thisand congruencecare dimension-incompatible. | 
| bool Parma_Polyhedra_Library::Polyhedron::is_disjoint_from | ( | const Polyhedron & | y | ) | const | 
Returns true if and only if *this and y are disjoint. 
| std::invalid_argument | Thrown if xandyare topology-incompatible or dimension-incompatible. | 
| bool Parma_Polyhedra_Library::Polyhedron::constrains | ( | Variable | var | ) | const | 
Returns true if and only if var is constrained in *this. 
| std::invalid_argument | Thrown if varis not a space dimension of*this. | 
| 
 | inline | 
Returns true if and only if expr is bounded from above in *this. 
| std::invalid_argument | Thrown if exprand*thisare dimension-incompatible. | 
| 
 | inline | 
Returns true if and only if expr is bounded from below in *this. 
| std::invalid_argument | Thrown if exprand*thisare dimension-incompatible. | 
| 
 | 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. 
| 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 | trueif and only if the supremum is also the maximum value. | 
| std::invalid_argument | Thrown if exprand*thisare 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. 
| 
 | 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. 
| 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 | trueif and only if the supremum is also the maximum value; | 
| g | When maximization succeeds, will be assigned the point or closure point where exprreaches its supremum value. | 
| std::invalid_argument | Thrown if exprand*thisare 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. 
| 
 | 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. 
| 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 | trueif and only if the infimum is also the minimum value. | 
| std::invalid_argument | Thrown if exprand*thisare 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. 
| 
 | 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. 
| 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 | trueif and only if the infimum is also the minimum value; | 
| g | When minimization succeeds, will be assigned a point or closure point where exprreaches its infimum value. | 
| std::invalid_argument | Thrown if exprand*thisare 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. 
| 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. 
| expr | The linear expression for which the frequency is needed; | 
| freq_n | If trueis 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 trueis returned, the value is set to ; | 
| val_n | The numerator of val; | 
| val_d | The denominator of val; | 
| std::invalid_argument | Thrown if exprand*thisare dimension-incompatible. | 
If false is returned, then freq_n, freq_d, val_n and val_d are left untouched. 
| bool Parma_Polyhedra_Library::Polyhedron::contains | ( | const Polyhedron & | y | ) | const | 
Returns true if and only if *this contains y. 
| std::invalid_argument | Thrown if *thisandyare topology-incompatible or dimension-incompatible. | 
| 
 | inline | 
Returns true if and only if *this strictly contains y. 
| std::invalid_argument | Thrown if *thisandyare topology-incompatible or dimension-incompatible. | 
| bool Parma_Polyhedra_Library::Polyhedron::OK | ( | bool | check_not_empty = false | ) | const | 
Checks if all the invariants are satisfied.
true if and only if *this satisfies all the invariants and either check_not_empty is false or *this is not empty.| check_not_empty | trueif and only if, in addition to checking the invariants,*thismust 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. 
| 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). 
| c | The constraint that will be added to the system of constraints of *this. | 
| std::invalid_argument | Thrown if *thisand constraintcare topology-incompatible or dimension-incompatible. | 
| 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). 
| std::invalid_argument | Thrown if *thisand generatorgare topology-incompatible or dimension-incompatible, or if*thisis an empty polyhedron andgis not a point. | 
| 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. 
| std::invalid_argument | Thrown if *thisand congruencecgare dimension-incompatible, of ifcgis a proper congruence which is neither a tautology, nor a contradiction. | 
| 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). 
| cs | Contains the constraints that will be added to the system of constraints of *this. | 
| std::invalid_argument | Thrown if *thisandcsare topology-incompatible or dimension-incompatible. | 
| 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). 
| cs | The constraint system to be added to *this. The constraints incsmay be recycled. | 
| std::invalid_argument | Thrown if *thisandcsare topology-incompatible or dimension-incompatible. | 
cs upon successful or exceptional return is that it can be safely destroyed. | 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). 
| gs | Contains the generators that will be added to the system of generators of *this. | 
| std::invalid_argument | Thrown if *thisandgsare topology-incompatible or dimension-incompatible, or if*thisis empty and the system of generatorsgsis not empty, but has no points. | 
| 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). 
| gs | The generator system to be added to *this. The generators ingsmay be recycled. | 
| std::invalid_argument | Thrown if *thisandgsare topology-incompatible or dimension-incompatible, or if*thisis empty and the system of generatorsgsis not empty, but has no points. | 
gs upon successful or exceptional return is that it can be safely destroyed. | 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. 
| cgs | The congruences to be added. | 
| std::invalid_argument | Thrown if *thisandcgsare dimension-incompatible, of if there exists incgsa proper congruence which is neither a tautology, nor a contradiction. | 
| 
 | inline | 
Adds the congruences in cgs to *this, if all the congruences can be exactly represented by a polyhedron. 
| cgs | The congruences to be added. Its elements may be recycled. | 
| std::invalid_argument | Thrown if *thisandcgsare dimension-incompatible, of if there exists incgsa proper congruence which is neither a tautology, nor a contradiction | 
cgs upon successful or exceptional return is that it can be safely destroyed. | void Parma_Polyhedra_Library::Polyhedron::refine_with_constraint | ( | const Constraint & | c | ) | 
Uses a copy of constraint c to refine *this. 
| std::invalid_argument | Thrown if *thisand constraintcare dimension-incompatible. | 
| void Parma_Polyhedra_Library::Polyhedron::refine_with_congruence | ( | const Congruence & | cg | ) | 
Uses a copy of congruence cg to refine *this. 
| std::invalid_argument | Thrown if *thisand congruencecgare dimension-incompatible. | 
| void Parma_Polyhedra_Library::Polyhedron::refine_with_constraints | ( | const Constraint_System & | cs | ) | 
Uses a copy of the constraints in cs to refine *this. 
| cs | Contains the constraints used to refine the system of constraints of *this. | 
| std::invalid_argument | Thrown if *thisandcsare dimension-incompatible. | 
| void Parma_Polyhedra_Library::Polyhedron::refine_with_congruences | ( | const Congruence_System & | cgs | ) | 
Uses a copy of the congruences in cgs to refine *this. 
| cgs | Contains the congruences used to refine the system of constraints of *this. | 
| std::invalid_argument | Thrown if *thisandcgsare dimension-incompatible. | 
| 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  
 right otherwise. 
| 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. | 
| std::invalid_argument | Thrown if left(orright) 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. 
| 
 | inline | 
Refines *this with the constraint expressed by left  
 right, where  is the relation symbol specified by
 is the relation symbol specified by relsym.. 
| 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. | 
| std::invalid_argument | Thrown if left(orright) is dimension-incompatible with*this. | 
| std::runtime_error | Thrown if relsymis 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. 
| 
 | inline | 
Refines store with the constraints defining *this. 
| store | The interval floating point abstract store to refine. | 
| void Parma_Polyhedra_Library::Polyhedron::unconstrain | ( | Variable | var | ) | 
Computes the cylindrification of *this with respect to space dimension var, assigning the result to *this. 
| var | The space dimension that will be unconstrained. | 
| std::invalid_argument | Thrown if varis not a space dimension of*this. | 
| 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. 
| vars | The set of space dimension that will be unconstrained. | 
| std::invalid_argument | Thrown if *thisis dimension-incompatible with one of the Variable objects contained invars. | 
| void Parma_Polyhedra_Library::Polyhedron::intersection_assign | ( | const Polyhedron & | y | ) | 
Assigns to *this the intersection of *this and y. 
| std::invalid_argument | Thrown if *thisandyare topology-incompatible or dimension-incompatible. | 
| void Parma_Polyhedra_Library::Polyhedron::poly_hull_assign | ( | const Polyhedron & | y | ) | 
Assigns to *this the poly-hull of *this and y. 
| std::invalid_argument | Thrown if *thisandyare topology-incompatible or dimension-incompatible. | 
| void Parma_Polyhedra_Library::Polyhedron::poly_difference_assign | ( | const Polyhedron & | y | ) | 
Assigns to *this the poly-difference of *this and y. 
| std::invalid_argument | Thrown if *thisandyare topology-incompatible or dimension-incompatible. | 
| 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. 
| std::invalid_argument | Thrown if *thisandyare topology-incompatible or dimension-incompatible. | 
| 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. 
| 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). | 
| std::invalid_argument | Thrown if denominatoris zero or ifexprand*thisare dimension-incompatible or ifvaris not a space dimension of*this. | 
| 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.
| 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. | 
| std::invalid_argument | Thrown if lfand*thisare dimension-incompatible or ifvaris 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. 
| 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. 
| 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). | 
| std::invalid_argument | Thrown if denominatoris zero or ifexprand*thisare dimension-incompatible or ifvaris not a space dimension of*this. | 
| 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  , where
, where  is the relation symbol encoded by
 is the relation symbol encoded by relsym. 
| 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). | 
| std::invalid_argument | Thrown if denominatoris zero or ifexprand*thisare dimension-incompatible or ifvaris not a space dimension of*thisor if*thisis a C_Polyhedron andrelsymis a strict relation symbol. | 
| 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  , where
, where  is the relation symbol encoded by
 is the relation symbol encoded by relsym. 
| 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). | 
| std::invalid_argument | Thrown if denominatoris zero or ifexprand*thisare dimension-incompatible or ifvaris not a space dimension of*thisor if*thisis a C_Polyhedron andrelsymis a strict relation symbol. | 
| 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  , where
, where  is the relation symbol encoded by
 is the relation symbol encoded by relsym. 
| lhs | The left hand side affine expression; | 
| relsym | The relation symbol; | 
| rhs | The right hand side affine expression. | 
| std::invalid_argument | Thrown if *thisis dimension-incompatible withlhsorrhsor if*thisis a C_Polyhedron andrelsymis a strict relation symbol. | 
| 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  , where
, where  is the relation symbol encoded by
 is the relation symbol encoded by relsym. 
| lhs | The left hand side affine expression; | 
| relsym | The relation symbol; | 
| rhs | The right hand side affine expression. | 
| std::invalid_argument | Thrown if *thisis dimension-incompatible withlhsorrhsor if*thisis a C_Polyhedron andrelsymis a strict relation symbol. | 
| 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  .
. 
| 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). | 
| std::invalid_argument | Thrown if denominatoris zero or iflb_expr(resp.,ub_expr) and*thisare dimension-incompatible or ifvaris not a space dimension of*this. | 
| 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  .
. 
| 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). | 
| std::invalid_argument | Thrown if denominatoris zero or iflb_expr(resp.,ub_expr) and*thisare dimension-incompatible or ifvaris not a space dimension of*this. | 
| 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. 
| std::invalid_argument | Thrown if *thisandyare topology-incompatible or dimension-incompatible. | 
| 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. 
| std::invalid_argument | Thrown if *thisandyare dimension-incompatible. | 
| 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.
| 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_pdepends on variables not invars, 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 | trueif the dimensions should be wrapped individually (something that results in much greater efficiency to the detriment of precision). | 
| std::invalid_argument | Thrown if *cs_pis dimension-incompatible withvars, or if*thisis dimension-incompatiblevarsor with*cs_p. | 
| 
 | inline | 
Possibly tightens *this by dropping some points with non-integer coordinates. 
| complexity | The maximal complexity of any algorithms used. | 
complexity is ANY_COMPLEXITY. | 
 | inline | 
Possibly tightens *this by dropping some points with non-integer coordinates for the space dimensions corresponding to vars. 
| vars | Points with non-integer coordinates for these variables/space-dimensions can be discarded. | 
| complexity | The maximal complexity of any algorithms used. | 
complexity is ANY_COMPLEXITY. | 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. 
| 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). | 
| std::invalid_argument | Thrown if *thisandyare topology-incompatible or dimension-incompatible. | 
| 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. 
| 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). | 
| std::invalid_argument | Thrown if *this,yandcsare topology-incompatible or dimension-incompatible. | 
| 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. 
| 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). | 
| std::invalid_argument | Thrown if *this,yandcsare topology-incompatible or dimension-incompatible. | 
| 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. 
| 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). | 
| std::invalid_argument | Thrown if *thisandyare topology-incompatible or dimension-incompatible. | 
| 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. 
| 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). | 
| std::invalid_argument | Thrown if *this,yandcsare topology-incompatible or dimension-incompatible. | 
| 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. 
| 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). | 
| std::invalid_argument | Thrown if *this,yandcsare topology-incompatible or dimension-incompatible. | 
| 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. 
| m | The number of dimensions to add. | 
| std::length_error | Thrown if adding mnew space dimensions would cause the vector space to exceed dimensionmax_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  and adding a third space dimension, the result will be the polyhedron
 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\}. \]](form_754.png) 
| 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. 
| m | The number of space dimensions to add. | 
| std::length_error | Thrown if adding mnew space dimensions would cause the vector space to exceed dimensionmax_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  and adding a third space dimension, the result will be the polyhedron
 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\}. \]](form_755.png) 
| void Parma_Polyhedra_Library::Polyhedron::concatenate_assign | ( | const Polyhedron & | y | ) | 
Assigns to *this the concatenation of *this and y, taken in this order. 
| std::invalid_argument | Thrown if *thisandyare topology-incompatible. | 
| std::length_error | Thrown if the concatenation would cause the vector space to exceed dimension max_space_dimension(). | 
| void Parma_Polyhedra_Library::Polyhedron::remove_space_dimensions | ( | const Variables_Set & | vars | ) | 
| 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. 
| std::invalid_argument | Thrown if new_dimensionsis greater than the space dimension of*this. | 
| void Parma_Polyhedra_Library::Polyhedron::map_space_dimensions | ( | const Partial_Function & | pfunc | ) | 
Remaps the dimensions of the vector space according to a partial function.
| pfunc | The partial function specifying the destiny of each space dimension. | 
The template type parameter Partial_Function must provide the following methods.
 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. 
 returns the maximum value that belongs to the codomain of the partial function. The max_in_codomain() method is called at most once. 
 Let  be the represented function and
 be the represented function and  be the value of
 be the value of i. If  is defined in
 is defined in  , then
, then  is assigned to
 is assigned to j and true is returned. If  is undefined in
 is undefined in  , then
, then false is returned. This method is called at most  times, where
 times, where  is the dimension of the vector space enclosing the polyhedron.
 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. 
| void Parma_Polyhedra_Library::Polyhedron::expand_space_dimension | ( | Variable | var, | 
| dimension_type | m | ||
| ) | 
Creates m copies of the space dimension corresponding to var. 
| var | The variable corresponding to the space dimension to be replicated; | 
| m | The number of replicas to be created. | 
| std::invalid_argument | Thrown if vardoes not correspond to a dimension of the vector space. | 
| std::length_error | Thrown if adding mnew space dimensions would cause the vector space to exceed dimensionmax_space_dimension(). | 
If *this has space dimension  , with
, with  , and
, and var has space dimension  , then the
, then the  -th space dimension is expanded to
-th space dimension is expanded to m new space dimensions  ,
,  ,
,  ,
,  .
. 
| void Parma_Polyhedra_Library::Polyhedron::fold_space_dimensions | ( | const Variables_Set & | vars, | 
| Variable | dest | ||
| ) | 
Folds the space dimensions in vars into dest. 
| 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. | 
| std::invalid_argument | Thrown if *thisis dimension-incompatible withdestor with one of the Variable objects contained invars. Also thrown ifdestis contained invars. | 
If *this has space dimension  , with
, with  ,
, dest has space dimension  ,
, vars is a set of variables whose maximum space dimension is also less than or equal to  , and
, and dest is not a member of vars, then the space dimensions corresponding to variables in vars are folded into the  -th space dimension.
-th space dimension. 
| 
 | inline | 
Swaps *this with polyhedron y. (*this and y can be dimension-incompatible.) 
| std::invalid_argument | Thrown if xandyare topology-incompatible. | 
| 
 | 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(). 
| 
 | protected | 
Possibly tightens *this by dropping some points with non-integer coordinates for the space dimensions corresponding to *vars_p. 
| vars_p | When nonzero, points with non-integer coordinates for the variables/space-dimensions contained in *vars_pcan be discarded. | 
| complexity | The maximal complexity of any algorithms used. | 
complexity is ANY_COMPLEXITY. | 
 | protected | 
Helper function that overapproximates an interval linear form.
| 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. 
| 
 | staticprotected | 
Helper function that makes result become a Linear_Expression obtained by normalizing the denominators in lf. 
| 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. 
| 
 | staticprotected | 
Normalization helper function.
| 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_coeffand all coefficients inres. | 
Results are obtained by normalizing denominators in lf, ignoring the upper bounds of variable coefficients in lf. 
| 
 | protected | 
Assuming *this is NNC, assigns to *this the result of the "positive time-elapse" between *this and y. 
| std::invalid_argument | Thrown if *thisandyare dimension-incompatible. | 
| 
 | related | 
Output operator.
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 ", ". 
| 
 | related | 
Swaps x with y. 
| 
 | related | 
Returns true if and only if x and y are the same polyhedron. 
Note that x and y may be topology- and/or dimension-incompatible polyhedra: in those cases, the value false is returned. 
| 
 | related | 
Returns true if and only if x and y are different polyhedra. 
Note that x and y may be topology- and/or dimension-incompatible polyhedra: in those cases, the value true is returned. 
| 
 | related | 
| 
 | related |