#include <ppl.hh>
Inherits Powerset< Parma_Polyhedra_Library::Determinate< PS > >.
Public Member Functions | |
| void | ascii_dump () const |
Writes to std::cerr an ASCII representation of *this. | |
| void | ascii_dump (std::ostream &s) const |
Writes to s an ASCII representation of *this. | |
| void | print () const |
Prints *this to std::cerr using operator<<. | |
| 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. | |
Constructors | |
| Pointset_Powerset (dimension_type num_dimensions=0, Degenerate_Element kind=UNIVERSE) | |
| Builds a universe (top) or empty (bottom) Pointset_Powerset. | |
| Pointset_Powerset (const Pointset_Powerset &y, Complexity_Class complexity=ANY_COMPLEXITY) | |
| Ordinary copy-constructor. | |
| template<typename QH > | |
| Pointset_Powerset (const Pointset_Powerset< QH > &y, Complexity_Class complexity=ANY_COMPLEXITY) | |
Conversion constructor: the type QH of the disjuncts in the source powerset is different from PS. | |
| template<typename QH1 , typename QH2 , typename R > | |
| Pointset_Powerset (const Partially_Reduced_Product< QH1, QH2, R > &prp, Complexity_Class complexity=ANY_COMPLEXITY) | |
| Creates a Pointset_Powerset from a product This will be created as a single disjunct of type PS that approximates the product. | |
| Pointset_Powerset (const Constraint_System &cs) | |
Creates a Pointset_Powerset with a single disjunct approximating the system of constraints cs. | |
| Pointset_Powerset (const Congruence_System &cgs) | |
Creates a Pointset_Powerset with a single disjunct approximating the system of congruences cgs. | |
| Pointset_Powerset (const C_Polyhedron &ph, Complexity_Class complexity=ANY_COMPLEXITY) | |
| Builds a pointset_powerset out of a closed polyhedron. | |
| Pointset_Powerset (const NNC_Polyhedron &ph, Complexity_Class complexity=ANY_COMPLEXITY) | |
| Builds a pointset_powerset out of an nnc polyhedron. | |
| Pointset_Powerset (const Grid &gr, Complexity_Class complexity=ANY_COMPLEXITY) | |
| Builds a pointset_powerset out of a grid. | |
| template<typename T > | |
| Pointset_Powerset (const Octagonal_Shape< T > &os, Complexity_Class complexity=ANY_COMPLEXITY) | |
| Builds a pointset_powerset out of an octagonal shape. | |
| template<typename T > | |
| Pointset_Powerset (const BD_Shape< T > &bds, Complexity_Class complexity=ANY_COMPLEXITY) | |
| Builds a pointset_powerset out of a bd shape. | |
| template<typename Interval > | |
| Pointset_Powerset (const Box< Interval > &box, Complexity_Class complexity=ANY_COMPLEXITY) | |
| Builds a pointset_powerset out of a box. | |
Member Functions that Do Not Modify the Pointset_Powerset | |
| dimension_type | space_dimension () const |
Returns the dimension of the vector space enclosing *this. | |
| dimension_type | affine_dimension () const |
Returns the dimension of the vector space enclosing *this. | |
| bool | is_empty () const |
Returns true if and only if *this is an empty powerset. | |
| bool | is_universe () const |
Returns true if and only if *this is the top element of the powerser lattice. | |
| bool | is_topologically_closed () const |
Returns true if and only if all the disjuncts in *this are topologically closed. | |
| bool | is_bounded () const |
Returns true if and only if all elements in *this are bounded. | |
| bool | is_disjoint_from (const Pointset_Powerset &y) const |
Returns true if and only if *this and y are disjoint. | |
| bool | is_discrete () const |
Returns true if and only if *this is discrete. | |
| bool | constrains (Variable var) const |
Returns true if and only if var is constrained in *this. | |
| bool | bounds_from_above (const Linear_Expression &expr) const |
Returns true if and only if expr is bounded from above in *this. | |
| bool | bounds_from_below (const Linear_Expression &expr) const |
Returns true if and only if expr is bounded from below in *this. | |
| 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. | |
| 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. | |
| 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. | |
| 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. | |
| bool | geometrically_covers (const Pointset_Powerset &y) const |
Returns true if and only if *this geometrically covers y, i.e., if any point (in some element) of y is also a point (of some element) of *this. | |
| bool | geometrically_equals (const Pointset_Powerset &y) const |
Returns true if and only if *this is geometrically equal to y, i.e., if (the elements of) *this and y contain the same set of points. | |
| bool | contains (const Pointset_Powerset &y) const |
Returns true if and only if each disjunct of y is contained in a disjunct of *this. | |
| bool | strictly_contains (const Pointset_Powerset &y) const |
Returns true if and only if each disjunct of y is strictly contained in a disjunct of *this. | |
| bool | contains_integer_point () const |
Returns true if and only if *this contains at least one integer point. | |
| Poly_Con_Relation | relation_with (const Constraint &c) const |
Returns the relations holding between the powerset *this and the constraint c. | |
| Poly_Gen_Relation | relation_with (const Generator &g) const |
Returns the relations holding between the powerset *this and the generator g. | |
| Poly_Con_Relation | relation_with (const Congruence &cg) const |
Returns the relations holding between the powerset *this and the congruence c. | |
| memory_size_type | total_memory_in_bytes () const |
Returns a lower bound to the total size in bytes of the memory occupied by *this. | |
| memory_size_type | external_memory_in_bytes () const |
Returns a lower bound to the size in bytes of the memory managed by *this. | |
| int32_t | hash_code () const |
Returns a 32-bit hash code for *this. | |
| bool | OK () const |
| Checks if all the invariants are satisfied. | |
Space Dimension Preserving Member Functions that May Modify the Pointset_Powerset | |
| void | add_disjunct (const PS &ph) |
Adds to *this the disjunct ph. | |
| void | add_constraint (const Constraint &c) |
Intersects *this with constraint c. | |
| void | refine_with_constraint (const Constraint &c) |
Use the constraint c to refine *this. | |
| bool | add_constraint_and_minimize (const Constraint &c) |
Intersects *this with the constraint c, minimizing the result. | |
| void | add_constraints (const Constraint_System &cs) |
Intersects *this with the constraints in cs. | |
| void | refine_with_constraints (const Constraint_System &cs) |
Use the constraints in cs to refine *this. | |
| bool | add_constraints_and_minimize (const Constraint_System &cs) |
Intersects *this with the constraints in cs, minimizing the result. | |
| void | add_congruence (const Congruence &c) |
Intersects *this with congruence c. | |
| void | refine_with_congruence (const Congruence &cg) |
Use the congruence cg to refine *this. | |
| bool | add_congruence_and_minimize (const Congruence &c) |
Intersects *this with the congruence c, minimizing the result. | |
| void | add_congruences (const Congruence_System &cgs) |
Intersects *this with the congruences in cgs. | |
| void | refine_with_congruences (const Congruence_System &cgs) |
Use the congruences in cgs to refine *this. | |
| bool | add_congruences_and_minimize (const Congruence_System &cs) |
Intersects *this with the congruences in cs, minimizing the result. | |
| void | unconstrain (Variable var) |
Computes the cylindrification of *this with respect to space dimension var, assigning the result to *this. | |
| void | unconstrain (const Variables_Set &to_be_unconstrained) |
Computes the cylindrification of *this with respect to the set of space dimensions to_be_unconstrained, assigning the result to *this. | |
| void | topological_closure_assign () |
Assigns to *this its topological closure. | |
| void | intersection_assign (const Pointset_Powerset &y) |
Assigns to *this the intersection of *this and y. | |
| bool | intersection_assign_and_minimize (const Pointset_Powerset &y) |
Assigns to *this the intersection of *this and y. | |
| void | difference_assign (const Pointset_Powerset &y) |
Assigns to *this an (a smallest) over-approximation as a powerset of the disjunct domain of the set-theoretical difference of *this and y. | |
| bool | simplify_using_context_assign (const Pointset_Powerset &y) |
Assigns to *this a meet-preserving simplification of *this with respect to y. If false is returned, then the intersection is empty. | |
| 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. | |
| 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. | |
| 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 , where is the relation symbol encoded by relsym. | |
| 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 , where is the relation symbol encoded by relsym. | |
| 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 , where is the relation symbol encoded by relsym. | |
| 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 , where is the relation symbol encoded by relsym. | |
| 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 . | |
| 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 . | |
| void | time_elapse_assign (const Pointset_Powerset &y) |
Assigns to *this the result of computing the time-elapse between *this and y. | |
| void | pairwise_reduce () |
Assign to *this the result of (recursively) merging together the pairs of disjuncts whose upper-bound is the same as their set-theoretical union. | |
| template<typename Widening > | |
| void | BGP99_extrapolation_assign (const Pointset_Powerset &y, Widening wf, unsigned max_disjuncts) |
Assigns to *this the result of applying the BGP99 extrapolation operator to *this and y, using the widening function wf and the cardinality threshold max_disjuncts. | |
| template<typename Cert , typename Widening > | |
| void | BHZ03_widening_assign (const Pointset_Powerset &y, Widening wf) |
Assigns to *this the result of computing the BHZ03-widening between *this and y, using the widening function wf certified by the convergence certificate Cert. | |
Member Functions that May Modify the Dimension of the Vector Space | |
| Pointset_Powerset & | operator= (const Pointset_Powerset &y) |
The assignment operator (*this and y can be dimension-incompatible). | |
| template<typename QH > | |
| Pointset_Powerset & | operator= (const Pointset_Powerset< QH > &y) |
Conversion assignment: the type QH of the disjuncts in the source powerset is different from PS (*this and y can be dimension-incompatible). | |
| void | swap (Pointset_Powerset &y) |
Swaps *this with y. | |
| void | add_space_dimensions_and_embed (dimension_type m) |
Adds m new dimensions to the vector space containing *this and embeds each disjunct in *this in the new space. | |
| void | add_space_dimensions_and_project (dimension_type m) |
Adds m new dimensions to the vector space containing *this without embedding the disjuncts in *this in the new space. | |
| void | concatenate_assign (const Pointset_Powerset &y) |
Assigns to *this the concatenation of *this and y. | |
| void | remove_space_dimensions (const Variables_Set &to_be_removed) |
| Removes all the specified space dimensions. | |
| void | remove_higher_space_dimensions (dimension_type new_dimension) |
Removes the higher space dimensions so that the resulting space will have dimension new_dimension. | |
| template<typename Partial_Function > | |
| void | map_space_dimensions (const Partial_Function &pfunc) |
| Remaps the dimensions of the vector space according to a partial function. | |
| void | expand_space_dimension (Variable var, dimension_type m) |
Creates m copies of the space dimension corresponding to var. | |
| void | fold_space_dimensions (const Variables_Set &to_be_folded, Variable var) |
Folds the space dimensions in to_be_folded into var. | |
Static Public Member Functions | |
| static dimension_type | max_space_dimension () |
| Returns the maximum space dimension a Pointset_Powerset<PS> can handle. | |
Related Functions | |
| (Note that these are not member functions.) | |
| template<typename PH > | |
| Widening_Function< PH > | widen_fun_ref (void(PH::*wm)(const PH &, unsigned *)) |
| Wraps a widening method into a function object. | |
| template<typename PH , typename CS > | |
| Limited_Widening_Function< PH, CS > | widen_fun_ref (void(PH::*lwm)(const PH &, const CS &, unsigned *), const CS &cs) |
| Wraps a limited widening method into a function object. | |
| template<typename PS > | |
| std::pair< PS, Pointset_Powerset < NNC_Polyhedron > > | linear_partition (const PS &p, const PS &q) |
Partitions q with respect to p. | |
| bool | check_containment (const NNC_Polyhedron &ph, const Pointset_Powerset< NNC_Polyhedron > &ps) |
Returns true if and only if the union of the NNC polyhedra in ps contains the NNC polyhedron ph. | |
| std::pair< Grid, Pointset_Powerset< Grid > > | approximate_partition (const Grid &p, const Grid &q, bool &finite_partition) |
Partitions the grid q with respect to grid p if and only if such a partition is finite. | |
| bool | check_containment (const Grid &ph, const Pointset_Powerset< Grid > &ps) |
Returns true if and only if the union of the grids ps contains the grid g. | |
| template<typename PS > | |
| bool | check_containment (const PS &ph, const Pointset_Powerset< PS > &ps) |
Returns true if and only if the union of the objects in ps contains ph. | |
| template<typename PS > | |
| void | swap (Parma_Polyhedra_Library::Pointset_Powerset< PS > &x, Parma_Polyhedra_Library::Pointset_Powerset< PS > &y) |
Specializes std::swap. | |
| template<> | |
| bool | check_containment (const C_Polyhedron &ph, const Pointset_Powerset< C_Polyhedron > &ps) |
PS are the simple pointset domains: C_Polyhedron, NNC_Polyhedron, Grid, Octagonal_Shape<T>, BD_Shape<T>, Box<T>. | Parma_Polyhedra_Library::Pointset_Powerset< PS >::Pointset_Powerset | ( | dimension_type | num_dimensions = 0, |
|
| Degenerate_Element | kind = UNIVERSE | |||
| ) | [inline, explicit] |
Builds a universe (top) or empty (bottom) Pointset_Powerset.
| num_dimensions | The number of dimensions of the vector space enclosing the powerset; | |
| kind | Specifies whether the universe or the empty powerset has to be built. |
| Parma_Polyhedra_Library::Pointset_Powerset< PS >::Pointset_Powerset | ( | const Pointset_Powerset< PS > & | y, | |
| Complexity_Class | complexity = ANY_COMPLEXITY | |||
| ) | [inline] |
Ordinary copy-constructor.
The complexity argument is ignored.
| Parma_Polyhedra_Library::Pointset_Powerset< PS >::Pointset_Powerset | ( | const Pointset_Powerset< QH > & | y, | |
| Complexity_Class | complexity = ANY_COMPLEXITY | |||
| ) | [inline, explicit] |
Conversion constructor: the type QH of the disjuncts in the source powerset is different from PS.
| y | The powerset to be used to build the new powerset. | |
| complexity | The maximal complexity of any algorithms used. |
| Parma_Polyhedra_Library::Pointset_Powerset< PS >::Pointset_Powerset | ( | const C_Polyhedron & | ph, | |
| Complexity_Class | complexity = ANY_COMPLEXITY | |||
| ) | [inline, explicit] |
Builds a pointset_powerset out of a closed polyhedron.
Builds a powerset that is either empty (if the polyhedron is found to be empty) or contains a single disjunct approximating the polyhedron; this must only use algorithms that do not exceed the specified complexity. The powerset inherits the space dimension of the polyhedron.
| ph | The closed polyhedron to be used to build the powerset. | |
| complexity | The maximal complexity of any algorithms used. |
| std::length_error | Thrown if the space dimension of ph exceeds the maximum allowed space dimension. |
| Parma_Polyhedra_Library::Pointset_Powerset< PS >::Pointset_Powerset | ( | const NNC_Polyhedron & | ph, | |
| Complexity_Class | complexity = ANY_COMPLEXITY | |||
| ) | [inline, explicit] |
Builds a pointset_powerset out of an nnc polyhedron.
Builds a powerset that is either empty (if the polyhedron is found to be empty) or contains a single disjunct approximating the polyhedron; this must only use algorithms that do not exceed the specified complexity. The powerset inherits the space dimension of the polyhedron.
| ph | The closed polyhedron to be used to build the powerset. | |
| complexity | The maximal complexity of any algorithms used. |
| std::length_error | Thrown if the space dimension of ph exceeds the maximum allowed space dimension. |
| Parma_Polyhedra_Library::Pointset_Powerset< PS >::Pointset_Powerset | ( | const Grid & | gr, | |
| Complexity_Class | complexity = ANY_COMPLEXITY | |||
| ) | [inline, explicit] |
Builds a pointset_powerset out of a grid.
If the grid is nonempty, builds a powerset containing a single disjunct approximating the grid. Builds the empty powerset otherwise. The powerset inherits the space dimension of the grid.
| gr | The grid to be used to build the powerset. | |
| complexity | This argument is ignored. |
| std::length_error | Thrown if the space dimension of gr exceeds the maximum allowed space dimension. |
| Parma_Polyhedra_Library::Pointset_Powerset< PS >::Pointset_Powerset | ( | const Octagonal_Shape< T > & | os, | |
| Complexity_Class | complexity = ANY_COMPLEXITY | |||
| ) | [inline, explicit] |
Builds a pointset_powerset out of an octagonal shape.
If the octagonal shape is nonempty, builds a powerset containing a single disjunct approximating the octagonal shape. Builds the empty powerset otherwise. The powerset inherits the space dimension of the octagonal shape.
| os | The octagonal shape to be used to build the powerset. | |
| complexity | This argument is ignored. |
| std::length_error | Thrown if the space dimension of os exceeds the maximum allowed space dimension. |
| Parma_Polyhedra_Library::Pointset_Powerset< PS >::Pointset_Powerset | ( | const BD_Shape< T > & | bds, | |
| Complexity_Class | complexity = ANY_COMPLEXITY | |||
| ) | [inline, explicit] |
Builds a pointset_powerset out of a bd shape.
If the bd shape is nonempty, builds a powerset containing a single disjunct approximating the bd shape. Builds the empty powerset otherwise. The powerset inherits the space dimension of the bd shape.
| bds | The bd shape to be used to build the powerset. | |
| complexity | This argument is ignored. |
| std::length_error | Thrown if the space dimension of bdss exceeds the maximum allowed space dimension. |
| Parma_Polyhedra_Library::Pointset_Powerset< PS >::Pointset_Powerset | ( | const Box< Interval > & | box, | |
| Complexity_Class | complexity = ANY_COMPLEXITY | |||
| ) | [inline, explicit] |
Builds a pointset_powerset out of a box.
If the box is nonempty, builds a powerset containing a single disjunct approximating the box. Builds the empty powerset otherwise. The powerset inherits the space dimension of the box.
| box | The box to be used to build the powerset. | |
| complexity | This argument is ignored. |
| std::length_error | Thrown if the space dimension of box exceeds the maximum allowed space dimension. |
| bool Parma_Polyhedra_Library::Pointset_Powerset< PS >::is_disjoint_from | ( | const Pointset_Powerset< PS > & | y | ) | const [inline] |
Returns true if and only if *this and y are disjoint.
| std::invalid_argument | Thrown if x and y are topology-incompatible or dimension-incompatible. |
| bool Parma_Polyhedra_Library::Pointset_Powerset< PS >::constrains | ( | Variable | var | ) | const [inline] |
Returns true if and only if var is constrained in *this.
| std::invalid_argument | Thrown if var is not a space dimension of *this. |
is constrained in the powerset
even though
is geometrically equal to the whole vector space.
| bool Parma_Polyhedra_Library::Pointset_Powerset< PS >::bounds_from_above | ( | const Linear_Expression & | expr | ) | const [inline] |
Returns true if and only if expr is bounded from above in *this.
| std::invalid_argument | Thrown if expr and *this are dimension-incompatible. |
| bool Parma_Polyhedra_Library::Pointset_Powerset< PS >::bounds_from_below | ( | const Linear_Expression & | expr | ) | const [inline] |
Returns true if and only if expr is bounded from below in *this.
| std::invalid_argument | Thrown if expr and *this are dimension-incompatible. |
| bool Parma_Polyhedra_Library::Pointset_Powerset< PS >::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.
| 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. |
| std::invalid_argument | Thrown if expr and *this are dimension-incompatible. |
*this is empty or expr is not bounded from above, false is returned and sup_n, sup_d and maximum are left untouched.
| bool Parma_Polyhedra_Library::Pointset_Powerset< PS >::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.
| 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. |
| std::invalid_argument | Thrown if expr and *this are dimension-incompatible. |
*this is empty or expr is not bounded from above, false is returned and sup_n, sup_d, maximum and g are left untouched.
| bool Parma_Polyhedra_Library::Pointset_Powerset< PS >::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.
| 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. |
| std::invalid_argument | Thrown if expr and *this are dimension-incompatible. |
*this is empty or expr is not bounded from below, false is returned and inf_n, inf_d and minimum are left untouched.
| bool Parma_Polyhedra_Library::Pointset_Powerset< PS >::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.
| 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. |
| std::invalid_argument | Thrown if expr and *this are dimension-incompatible. |
*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::Pointset_Powerset< PS >::geometrically_covers | ( | const Pointset_Powerset< PS > & | y | ) | const [inline] |
Returns true if and only if *this geometrically covers y, i.e., if any point (in some element) of y is also a point (of some element) of *this.
| std::invalid_argument | Thrown if *this and y are dimension-incompatible. |
| bool Parma_Polyhedra_Library::Pointset_Powerset< PS >::geometrically_equals | ( | const Pointset_Powerset< PS > & | y | ) | const [inline] |
Returns true if and only if *this is geometrically equal to y, i.e., if (the elements of) *this and y contain the same set of points.
| std::invalid_argument | Thrown if *this and y are dimension-incompatible. |
| bool Parma_Polyhedra_Library::Pointset_Powerset< PS >::contains | ( | const Pointset_Powerset< PS > & | y | ) | const [inline] |
Returns true if and only if each disjunct of y is contained in a disjunct of *this.
| std::invalid_argument | Thrown if *this and y are topology-incompatible or dimension-incompatible. |
| bool Parma_Polyhedra_Library::Pointset_Powerset< PS >::strictly_contains | ( | const Pointset_Powerset< PS > & | y | ) | const [inline] |
Returns true if and only if each disjunct of y is strictly contained in a disjunct of *this.
| std::invalid_argument | Thrown if *this and y are topology-incompatible or dimension-incompatible. |
| Poly_Con_Relation Parma_Polyhedra_Library::Pointset_Powerset< PS >::relation_with | ( | const Constraint & | c | ) | const [inline] |
Returns the relations holding between the powerset *this and the constraint c.
| std::invalid_argument | Thrown if *this and constraint c are dimension-incompatible. |
| Poly_Gen_Relation Parma_Polyhedra_Library::Pointset_Powerset< PS >::relation_with | ( | const Generator & | g | ) | const [inline] |
Returns the relations holding between the powerset *this and the generator g.
| std::invalid_argument | Thrown if *this and generator g are dimension-incompatible. |
| Poly_Con_Relation Parma_Polyhedra_Library::Pointset_Powerset< PS >::relation_with | ( | const Congruence & | cg | ) | const [inline] |
Returns the relations holding between the powerset *this and the congruence c.
| std::invalid_argument | Thrown if *this and congruence c are dimension-incompatible. |
| int32_t Parma_Polyhedra_Library::Pointset_Powerset< PS >::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().
| void Parma_Polyhedra_Library::Pointset_Powerset< PS >::add_disjunct | ( | const PS & | ph | ) | [inline] |
Adds to *this the disjunct ph.
| std::invalid_argument | Thrown if *this and ph are dimension-incompatible. |
| void Parma_Polyhedra_Library::Pointset_Powerset< PS >::add_constraint | ( | const Constraint & | c | ) | [inline] |
Intersects *this with constraint c.
| std::invalid_argument | Thrown if *this and constraint c are topology-incompatible or dimension-incompatible. |
| void Parma_Polyhedra_Library::Pointset_Powerset< PS >::refine_with_constraint | ( | const Constraint & | c | ) | [inline] |
Use the constraint c to refine *this.
| c | The constraint to be used for refinement. |
| std::invalid_argument | Thrown if *this and c are dimension-incompatible. |
| bool Parma_Polyhedra_Library::Pointset_Powerset< PS >::add_constraint_and_minimize | ( | const Constraint & | c | ) | [inline] |
Intersects *this with the constraint c, minimizing the result.
false if and only if the result is empty.| std::invalid_argument | Thrown if *this and c are topology-incompatible or dimension-incompatible. |
| void Parma_Polyhedra_Library::Pointset_Powerset< PS >::add_constraints | ( | const Constraint_System & | cs | ) | [inline] |
Intersects *this with the constraints in cs.
| cs | The constraints to intersect with. |
| std::invalid_argument | Thrown if *this and cs are topology-incompatible or dimension-incompatible. |
| void Parma_Polyhedra_Library::Pointset_Powerset< PS >::refine_with_constraints | ( | const Constraint_System & | cs | ) | [inline] |
Use the constraints in cs to refine *this.
| cs | The constraints to be used for refinement. |
| std::invalid_argument | Thrown if *this and cs are dimension-incompatible. |
| bool Parma_Polyhedra_Library::Pointset_Powerset< PS >::add_constraints_and_minimize | ( | const Constraint_System & | cs | ) | [inline] |
Intersects *this with the constraints in cs, minimizing the result.
false if and only if the result is empty.| cs | The constraints to intersect with. |
| std::invalid_argument | Thrown if *this and cs are topology-incompatible or dimension-incompatible. |
| void Parma_Polyhedra_Library::Pointset_Powerset< PS >::add_congruence | ( | const Congruence & | c | ) | [inline] |
Intersects *this with congruence c.
| std::invalid_argument | Thrown if *this and congruence c are topology-incompatible or dimension-incompatible. |
| void Parma_Polyhedra_Library::Pointset_Powerset< PS >::refine_with_congruence | ( | const Congruence & | cg | ) | [inline] |
Use the congruence cg to refine *this.
| cg | The congruence to be used for refinement. |
| std::invalid_argument | Thrown if *this and cg are dimension-incompatible. |
| bool Parma_Polyhedra_Library::Pointset_Powerset< PS >::add_congruence_and_minimize | ( | const Congruence & | c | ) | [inline] |
Intersects *this with the congruence c, minimizing the result.
false if and only if the result is empty.| std::invalid_argument | Thrown if *this and c are topology-incompatible or dimension-incompatible. |
| void Parma_Polyhedra_Library::Pointset_Powerset< PS >::add_congruences | ( | const Congruence_System & | cgs | ) | [inline] |
Intersects *this with the congruences in cgs.
| cgs | The congruences to intersect with. |
| std::invalid_argument | Thrown if *this and cgs are topology-incompatible or dimension-incompatible. |
| void Parma_Polyhedra_Library::Pointset_Powerset< PS >::refine_with_congruences | ( | const Congruence_System & | cgs | ) | [inline] |
Use the congruences in cgs to refine *this.
| cgs | The congruences to be used for refinement. |
| std::invalid_argument | Thrown if *this and cgs are dimension-incompatible. |
| bool Parma_Polyhedra_Library::Pointset_Powerset< PS >::add_congruences_and_minimize | ( | const Congruence_System & | cs | ) | [inline] |
Intersects *this with the congruences in cs, minimizing the result.
false if and only if the result is empty.| cs | The congruences to intersect with. |
| std::invalid_argument | Thrown if *this and cs are topology-incompatible or dimension-incompatible. |
| void Parma_Polyhedra_Library::Pointset_Powerset< PS >::unconstrain | ( | Variable | var | ) | [inline] |
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 var is not a space dimension of *this. |
| void Parma_Polyhedra_Library::Pointset_Powerset< PS >::unconstrain | ( | const Variables_Set & | to_be_unconstrained | ) | [inline] |
Computes the cylindrification of *this with respect to the set of space dimensions to_be_unconstrained, assigning the result to *this.
| to_be_unconstrained | The set of space dimension that will be unconstrained. |
| std::invalid_argument | Thrown if *this is dimension-incompatible with one of the Variable objects contained in to_be_removed. |
| void Parma_Polyhedra_Library::Pointset_Powerset< PS >::intersection_assign | ( | const Pointset_Powerset< PS > & | y | ) | [inline] |
Assigns to *this the intersection of *this and y.
The result is obtained by intersecting each disjunct in *this with each disjunct in y and collecting all these intersections.
| bool Parma_Polyhedra_Library::Pointset_Powerset< PS >::intersection_assign_and_minimize | ( | const Pointset_Powerset< PS > & | y | ) | [inline] |
Assigns to *this the intersection of *this and y.
The result is obtained by intersecting each disjunct in *this with each disjunct in y, minimizing the result and collecting all these intersections.
false if and only if the result is empty.| void Parma_Polyhedra_Library::Pointset_Powerset< PS >::difference_assign | ( | const Pointset_Powerset< PS > & | y | ) | [inline] |
Assigns to *this an (a smallest) over-approximation as a powerset of the disjunct domain of the set-theoretical difference of *this and y.
| std::invalid_argument | Thrown if *this and y are dimension-incompatible. |
| bool Parma_Polyhedra_Library::Pointset_Powerset< PS >::simplify_using_context_assign | ( | const Pointset_Powerset< PS > & | y | ) | [inline] |
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 *this and y are topology-incompatible or dimension-incompatible. |
| void Parma_Polyhedra_Library::Pointset_Powerset< PS >::affine_image | ( | Variable | var, | |
| const Linear_Expression & | expr, | |||
| Coefficient_traits::const_reference | denominator = Coefficient_one() | |||
| ) | [inline] |
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 denominator is zero or if expr and *this are dimension-incompatible or if var is not a space dimension of *this. |
| void Parma_Polyhedra_Library::Pointset_Powerset< PS >::affine_preimage | ( | Variable | var, | |
| const Linear_Expression & | expr, | |||
| Coefficient_traits::const_reference | denominator = Coefficient_one() | |||
| ) | [inline] |
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 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 denominator is zero or if expr and *this are dimension-incompatible or if var is not a space dimension of *this. |
| void Parma_Polyhedra_Library::Pointset_Powerset< PS >::generalized_affine_image | ( | Variable | var, | |
| Relation_Symbol | relsym, | |||
| const Linear_Expression & | expr, | |||
| Coefficient_traits::const_reference | denominator = Coefficient_one() | |||
| ) | [inline] |
Assigns to *this the image of *this with respect to the generalized affine relation
, where
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 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. |
| void Parma_Polyhedra_Library::Pointset_Powerset< PS >::generalized_affine_preimage | ( | Variable | var, | |
| Relation_Symbol | relsym, | |||
| const Linear_Expression & | expr, | |||
| Coefficient_traits::const_reference | denominator = Coefficient_one() | |||
| ) | [inline] |
Assigns to *this the preimage of *this with respect to the generalized affine relation
, where
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 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. |
| void Parma_Polyhedra_Library::Pointset_Powerset< PS >::generalized_affine_image | ( | const Linear_Expression & | lhs, | |
| Relation_Symbol | relsym, | |||
| const Linear_Expression & | rhs | |||
| ) | [inline] |
Assigns to *this the image of *this with respect to the generalized affine relation
, where
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 *this is dimension-incompatible with lhs or rhs or if *this is a C_Polyhedron and relsym is a strict relation symbol. |
| void Parma_Polyhedra_Library::Pointset_Powerset< PS >::generalized_affine_preimage | ( | const Linear_Expression & | lhs, | |
| Relation_Symbol | relsym, | |||
| const Linear_Expression & | rhs | |||
| ) | [inline] |
Assigns to *this the preimage of *this with respect to the generalized affine relation
, where
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 *this is dimension-incompatible with lhs or rhs or if *this is a C_Polyhedron and relsym is a strict relation symbol. |
| void Parma_Polyhedra_Library::Pointset_Powerset< PS >::bounded_affine_image | ( | Variable | var, | |
| const Linear_Expression & | lb_expr, | |||
| const Linear_Expression & | ub_expr, | |||
| Coefficient_traits::const_reference | denominator = Coefficient_one() | |||
| ) | [inline] |
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 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. |
| void Parma_Polyhedra_Library::Pointset_Powerset< PS >::bounded_affine_preimage | ( | Variable | var, | |
| const Linear_Expression & | lb_expr, | |||
| const Linear_Expression & | ub_expr, | |||
| Coefficient_traits::const_reference | denominator = Coefficient_one() | |||
| ) | [inline] |
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 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. |
| void Parma_Polyhedra_Library::Pointset_Powerset< PS >::time_elapse_assign | ( | const Pointset_Powerset< PS > & | y | ) | [inline] |
Assigns to *this the result of computing the time-elapse between *this and y.
The result is obtained by computing the pairwise time elapse of each disjunct in *this with each disjunct in y.
| void Parma_Polyhedra_Library::Pointset_Powerset< PS >::pairwise_reduce | ( | ) | [inline] |
Assign to *this the result of (recursively) merging together the pairs of disjuncts whose upper-bound is the same as their set-theoretical union.
On exit, for all the pairs
,
of different disjuncts in *this, we have
.
| void Parma_Polyhedra_Library::Pointset_Powerset< PS >::BGP99_extrapolation_assign | ( | const Pointset_Powerset< PS > & | y, | |
| Widening | wf, | |||
| unsigned | max_disjuncts | |||
| ) | [inline] |
Assigns to *this the result of applying the BGP99 extrapolation operator to *this and y, using the widening function wf and the cardinality threshold max_disjuncts.
| y | A powerset that must definitely entail *this; | |
| wf | The widening function to be used on polyhedra objects. It is obtained from the corresponding widening method by using the helper function Parma_Polyhedra_Library::widen_fun_ref. Legal values are, e.g., widen_fun_ref(&Polyhedron::H79_widening_assign) and widen_fun_ref(&Polyhedron::limited_H79_extrapolation_assign, cs); | |
| max_disjuncts | The maximum number of disjuncts occurring in the powerset *this before starting the computation. If this number is exceeded, some of the disjuncts in *this are collapsed (i.e., joined together). |
| std::invalid_argument | Thrown if *this and y are dimension-incompatible. |
| void Parma_Polyhedra_Library::Pointset_Powerset< PS >::BHZ03_widening_assign | ( | const Pointset_Powerset< PS > & | y, | |
| Widening | wf | |||
| ) | [inline] |
Assigns to *this the result of computing the BHZ03-widening between *this and y, using the widening function wf certified by the convergence certificate Cert.
| y | The finite powerset computed in the previous iteration step. It must definitely entail *this; | |
| wf | The widening function to be used on disjuncts. It is obtained from the corresponding widening method by using the helper function widen_fun_ref. Legal values are, e.g., widen_fun_ref(&Polyhedron::H79_widening_assign) and widen_fun_ref(&Polyhedron::limited_H79_extrapolation_assign, cs). |
| std::invalid_argument | Thrown if *this and y are dimension-incompatible. |
Cert should be a finite convergence certificate for the base-level widening function wf; otherwise, an extrapolation operator is obtained. For a description of the methods that should be provided by Cert, see BHRZ03_Certificate or H79_Certificate. | void Parma_Polyhedra_Library::Pointset_Powerset< PS >::concatenate_assign | ( | const Pointset_Powerset< PS > & | y | ) | [inline] |
Assigns to *this the concatenation of *this and y.
The result is obtained by computing the pairwise concatenation of each disjunct in *this with each disjunct in y.
| void Parma_Polyhedra_Library::Pointset_Powerset< PS >::remove_space_dimensions | ( | const Variables_Set & | to_be_removed | ) | [inline] |
| void Parma_Polyhedra_Library::Pointset_Powerset< PS >::remove_higher_space_dimensions | ( | dimension_type | new_dimension | ) | [inline] |
Removes the higher space dimensions so that the resulting space will have dimension new_dimension.
| std::invalid_argument | Thrown if new_dimensions is greater than the space dimension of *this. |
| void Parma_Polyhedra_Library::Pointset_Powerset< PS >::map_space_dimensions | ( | const Partial_Function & | pfunc | ) | [inline] |
Remaps the dimensions of the vector space according to a partial function.
See also Polyhedron::map_space_dimensions.
| void Parma_Polyhedra_Library::Pointset_Powerset< PS >::expand_space_dimension | ( | Variable | var, | |
| dimension_type | m | |||
| ) | [inline] |
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 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(). |
*this has space dimension
, with
, and var has space dimension
, then the
-th space dimension is expanded to m new space dimensions
,
,
,
.
| void Parma_Polyhedra_Library::Pointset_Powerset< PS >::fold_space_dimensions | ( | const Variables_Set & | to_be_folded, | |
| Variable | var | |||
| ) | [inline] |
Folds the space dimensions in to_be_folded into var.
| to_be_folded | The set of Variable objects corresponding to the space dimensions to be folded; | |
| var | The variable corresponding to the space dimension that is the destination of the folding operation. |
| std::invalid_argument | Thrown if *this is dimension-incompatible with var or with one of the Variable objects contained in to_be_folded. Also thrown if var is contained in to_be_folded. |
*this has space dimension
, with
, var has space dimension
, to_be_folded is a set of variables whose maximum space dimension is also less than or equal to
, and var is not a member of to_be_folded, then the space dimensions corresponding to variables in to_be_folded are folded into the
-th space dimension.
| Widening_Function< PH > widen_fun_ref | ( | void(PH::*)(const PH &, unsigned *) | wm | ) | [related] |
Wraps a widening method into a function object.
| wm | The widening method. |
| Limited_Widening_Function< PH, CS > widen_fun_ref | ( | void(PH::*)(const PH &, const CS &, unsigned *) | lwm, | |
| const CS & | cs | |||
| ) | [related] |
Wraps a limited widening method into a function object.
| lwm | The limited widening method. | |
| cs | The constraint system limiting the widening. |
| std::pair< PS, Pointset_Powerset< NNC_Polyhedron > > linear_partition | ( | const PS & | p, | |
| const PS & | q | |||
| ) | [related] |
Partitions q with respect to p.
Let p and q be two polyhedra. The function returns an object r of type std::pair<PS, Pointset_Powerset<NNC_Polyhedron> > such that
r.first is the intersection of p and q;r.second has the property that all its elements are pairwise disjoint and disjoint from p;r.first with all the elements of r.second gives q (i.e., r is the representation of a partition of q).| std::pair< Grid, Pointset_Powerset< Grid > > approximate_partition | ( | const Grid & | p, | |
| const Grid & | q, | |||
| bool & | finite_partition | |||
| ) | [related] |
Partitions the grid q with respect to grid p if and only if such a partition is finite.
Let p and q be two grids. The function returns an object r of type std::pair<PS, Pointset_Powerset<Grid> > such that
r.first is the intersection of p and q;q wrt p the Boolean finite_partition is set to true and r.second has the property that all its elements are pairwise disjoint and disjoint from p and the set-theoretical union of r.first with all the elements of r.second gives q (i.e., r is the representation of a partition of q).finite_partition is set to false and the singleton set that contains q is stored in r.secondr. | bool check_containment | ( | const PS & | ph, | |
| const Pointset_Powerset< PS > & | ps | |||
| ) | [related] |
Returns true if and only if the union of the objects in ps contains ph.
| void swap | ( | Parma_Polyhedra_Library::Pointset_Powerset< PS > & | x, | |
| Parma_Polyhedra_Library::Pointset_Powerset< PS > & | y | |||
| ) | [related] |
Specializes std::swap.
| bool check_containment | ( | const C_Polyhedron & | ph, | |
| const Pointset_Powerset< C_Polyhedron > & | ps | |||
| ) | [related] |
1.5.7.1