PPL: Parma_Polyhedra_Library::Polyhedron Class Reference

Main Page | Modules | Namespace List | Class Hierarchy | Class List | Namespace Members | Class Members | Related Pages

# Parma_Polyhedra_Library::Polyhedron Class Reference

The base class for convex polyhedra. More...

Inherited by Parma_Polyhedra_Library::C_Polyhedron, and Parma_Polyhedra_Library::NNC_Polyhedron.

List of all members.

## Public Types
enum | Degenerate_Kind { UNIVERSE, EMPTY }
| Kinds of degenerate polyhedra. More...
## 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`.
const ConSys & | constraints () const
| Returns the system of constraints.
const ConSys & | minimized_constraints () const
| Returns the system of constraints, with no redundant constraint.
const GenSys & | generators () const
| Returns the system of generators.
const GenSys & | minimized_generators () const
| Returns the system of generators, with no redundant generator.
Poly_Con_Relation | relation_with (const Constraint &c) const
| Returns the relations holding between the polyhedron `*this` and the constraint `c`.
Poly_Gen_Relation | relation_with (const Generator &g) const
| Returns the relations holding between the polyhedron `*this` and the generator `g`.
bool | is_empty () const
| Returns `true` if and only if `*this` is an empty polyhedron.
bool | is_universe () const
| Returns `true` if and only if `*this` is a universe polyhedron.
bool | is_topologically_closed () const
| Returns `true` if and only if `*this` is a topologically closed subset of the vector space.
bool | is_disjoint_from (const Polyhedron &y) const
| Returns `true` if and only if `*this` and `y` are disjoint.
bool | is_bounded () const
| Returns `true` if and only if `*this` is a bounded polyhedron.
bool | bounds_from_above (const LinExpression &expr) const
| Returns `true` if and only if `expr` is bounded from above in `*this`.
bool | bounds_from_below (const LinExpression &expr) const
| Returns `true` if and only if `expr` is bounded from below in `*this`.
bool | maximize (const LinExpression &expr, Integer &sup_n, Integer &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 LinExpression &expr, Integer &sup_n, Integer &sup_d, bool &maximum, const Generator **const pppoint) 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 LinExpression &expr, Integer &inf_n, Integer &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 LinExpression &expr, Integer &inf_n, Integer &inf_d, bool &minimum, const Generator **const pppoint) 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 | contains (const Polyhedron &y) const
| Returns `true` if and only if `*this` contains `y`.
bool | strictly_contains (const Polyhedron &y) const
| Returns `true` if and only if `*this` strictly contains `y`.
template<typename Box> void | shrink_bounding_box (Box &box, Complexity_Class complexity=ANY) const
| Uses `*this` to shrink a generic, interval-based bounding box.
bool | OK (bool check_not_empty=false) const
| Checks if all the invariants are satisfied.
Space-Dimension Preserving Member Functions that May Modify the Polyhedron
void | add_constraint (const Constraint &c)
| Adds a copy of constraint `c` to the system of constraints of `*this` (without minimizing the result).
bool | add_constraint_and_minimize (const Constraint &c)
| Adds a copy of constraint `c` to the system of constraints of `*this`, minimizing the result.
void | add_generator (const Generator &g)
| Adds a copy of generator `g` to the system of generators of `*this` (without minimizing the result).
bool | add_generator_and_minimize (const Generator &g)
| Adds a copy of generator `g` to the system of generators of `*this`, minimizing the result.
void | add_constraints (const ConSys &cs)
| Adds a copy of the constraints in `cs` to the system of constraints of `*this` (without minimizing the result).
void | add_recycled_constraints (ConSys &cs)
| Adds the constraints in `cs` to the system of constraints of `*this` (without minimizing the result).
bool | add_constraints_and_minimize (const ConSys &cs)
| Adds a copy of the constraints in `cs` to the system of constraints of `*this`, minimizing the result.
bool | add_recycled_constraints_and_minimize (ConSys &cs)
| Adds the constraints in `cs` to the system of constraints of `*this`, minimizing the result.
void | add_generators (const GenSys &gs)
| Adds a copy of the generators in `gs` to the system of generators of `*this` (without minimizing the result).
void | add_recycled_generators (GenSys &gs)
| Adds the generators in `gs` to the system of generators of `*this` (without minimizing the result).
bool | add_generators_and_minimize (const GenSys &gs)
| Adds a copy of the generators in `gs` to the system of generators of `*this`, minimizing the result.
bool | add_recycled_generators_and_minimize (GenSys &gs)
| Adds the generators in `gs` to the system of generators of `*this`, minimizing the result.
void | intersection_assign (const Polyhedron &y)
| Assigns to `*this` the intersection of `*this` and `y`. The result is not guaranteed to be minimized.
bool | intersection_assign_and_minimize (const Polyhedron &y)
| Assigns to `*this` the intersection of `*this` and `y`, minimizing the result.
void | poly_hull_assign (const Polyhedron &y)
| Assigns to `*this` the poly-hull of `*this` and `y`. The result is not guaranteed to be minimized.
bool | poly_hull_assign_and_minimize (const Polyhedron &y)
| Assigns to `*this` the poly-hull of `*this` and `y`, minimizing the result.
void | poly_difference_assign (const Polyhedron &y)
| Assigns to `*this` the poly-difference of `*this` and `y`. The result is not guaranteed to be minimized.
void | affine_image (Variable var, const LinExpression &expr, const Integer &denominator=Integer_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 LinExpression &expr, const Integer &denominator=Integer_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, const Relation_Symbol relsym, const LinExpression &expr, const Integer &denominator=Integer_one())
| Assigns to `*this` the image of `*this` with respect to the generalized affine transfer function , where is the relation symbol encoded by `relsym`.
void | generalized_affine_image (const LinExpression &lhs, const Relation_Symbol relsym, const LinExpression &rhs)
| Assigns to `*this` the image of `*this` with respect to the generalized affine transfer function , where is the relation symbol encoded by `relsym`.
void | time_elapse_assign (const Polyhedron &y)
| Assigns to `*this` the result of computing the time-elapse between `*this` and `y`.
void | topological_closure_assign ()
| Assigns to `*this` its topological closure.
void | BHRZ03_widening_assign (const Polyhedron &y, unsigned *tp=0)
| Assigns to `*this` the result of computing the BHRZ03-widening between `*this` and `y`.
void | limited_BHRZ03_extrapolation_assign (const Polyhedron &y, const ConSys &cs, unsigned *tp=0)
| Improves the result of the BHRZ03-widening computation by also enforcing those constraints in `cs` that are satisfied by all the points of `*this`.
void | bounded_BHRZ03_extrapolation_assign (const Polyhedron &y, const ConSys &cs, unsigned *tp=0)
| Improves the result of the BHRZ03-widening computation by also enforcing those constraints in `cs` that are satisfied by all the points of `*this`, plus all the constraints of the form and , with , that are satisfied by all the points of `*this`.
void | H79_widening_assign (const Polyhedron &y, unsigned *tp=0)
| Assigns to `*this` the result of computing the H79-widening between `*this` and `y`.
void | limited_H79_extrapolation_assign (const Polyhedron &y, const ConSys &cs, unsigned *tp=0)
| Improves the result of the H79-widening computation by also enforcing those constraints in `cs` that are satisfied by all the points of `*this`.
void | bounded_H79_extrapolation_assign (const Polyhedron &y, const ConSys &cs, unsigned *tp=0)
| Improves the result of the H79-widening computation by also enforcing those constraints in `cs` that are satisfied by all the points of `*this`, plus all the constraints of the form and , with , that are satisfied by all the points of `*this`.
Member Functions that May Modify the Dimension of the Vector Space
void | add_dimensions_and_embed (dimension_type m)
| Adds `m` new dimensions and embeds the old polyhedron in the new space.
void | add_dimensions_and_project (dimension_type m)
| Adds `m` new dimensions to the polyhedron and does not embed it in the new space.
void | concatenate_assign (const Polyhedron &y)
| Assigns to `*this` the concatenation of `*this` and `y`, taken in this order.
void | remove_dimensions (const Variables_Set &to_be_removed)
| Removes all the specified dimensions.
void | remove_higher_dimensions (dimension_type new_dimension)
| Removes the higher dimensions so that the resulting space will have dimension `new_dimension`.
template<typename PartialFunction> void | map_dimensions (const PartialFunction &pfunc)
| Remaps the dimensions of the vector space according to a partial function.
void | expand_dimension (Variable var, dimension_type m)
| Creates `m` copies of the dimension corresponding to `var`.
void | fold_dimensions (const Variables_Set &to_be_folded, Variable var)
| Folds the dimensions in `to_be_folded` into `var`.
Miscellaneous Member Functions
| ~Polyhedron ()
| Destructor.
void | swap (Polyhedron &y)
| Swaps `*this` with polyhedron `y`. (`*this` and `y` can be dimension-incompatible.).
## Static Public Member Functions
dimension_type | max_space_dimension ()
| Returns the maximum space dimension all kinds of Polyhedron can handle.
## Protected Member Functions
| Polyhedron (Topology topol, dimension_type num_dimensions, Degenerate_Kind kind)
| Builds a polyhedron having the specified properties.
| Polyhedron (const Polyhedron &y)
| Ordinary copy-constructor.
| Polyhedron (Topology topol, const ConSys &cs)
| Builds a polyhedron from a system of constraints.
| Polyhedron (Topology topol, ConSys &cs)
| Builds a polyhedron recycling a system of constraints.
| Polyhedron (Topology topol, const GenSys &gs)
| Builds a polyhedron from a system of generators.
| Polyhedron (Topology topol, GenSys &gs)
| Builds a polyhedron recycling a system of generators.
template<typename Box> | Polyhedron (Topology topol, const Box &box)
| Builds a polyhedron out of a generic, interval-based bounding box.
Polyhedron & | operator= (const Polyhedron &y)
| The assignment operator. (`*this` and `y` can be dimension-incompatible.).
## Related Functions
(Note that these are not member functions.)
std::ostream & | operator<< (std::ostream &s, const Polyhedron &ph)
| Output operator.
bool | operator== (const Polyhedron &x, const Polyhedron &y)
| Returns `true` if and only if `x` and `y` are the same polyhedron.
bool | operator!= (const Polyhedron &x, const Polyhedron &y)
| Returns `true` if and only if `x` and `y` are different polyhedra.
void | swap (Parma_Polyhedra_Library::Polyhedron &x, Parma_Polyhedra_Library::Polyhedron &y)
| Specializes `std::swap`.
template<typename PH> bool | poly_hull_assign_if_exact (PH &p, const PH &q)
| If the poly-hull between `p` and `q` is exact it is assigned to `p`.

## Detailed Description

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. Most operators on polyhedra are provided with two implementations: one of these, denoted `<operator-name>_and_minimize`, also enforces the minimization of the representations, and returns the Boolean value `false` whenever the resulting polyhedron turns out to be empty.

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):

- all polyhedra, the empty ones included, are endowed with a specific topology and space dimension;
- most operations working on a polyhedron and another object (i.e., another polyhedron, a constraint or generator, a set of variables, etc.) will throw an exception if the polyhedron and the object are not both topology-compatible and dimension-compatible (see Section Representations of Convex Polyhedra);
- there is no way to change the topology of a polyhedron; rather, there are constructors of the two derived classes that builds a new polyhedron having a topology when provided with the corresponding polyhedron of the other topology;
- the only ways to change the space dimension of a polyhedron are:
  - explicit calls to operators provided for that purpose;
  - standard copy, assignment and swap operators.

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

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

        Variable x(0);
        Variable y(1);

Example 1
  The following code builds a polyhedron corresponding to a square in , given as a system of constraints:

        ConSys cs;
        cs.insert(x >= 0);
        cs.insert(x <= 3);
        cs.insert(y >= 0);
        cs.insert(y <= 3);
        C_Polyhedron ph(cs);

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

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

Example 2
  The following code builds an unbounded polyhedron corresponding to a half-strip in , given as a system of constraints:

        ConSys cs;
        cs.insert(x >= 0);
        cs.insert(x - y <= 0);
        cs.insert(x - y + 1 >= 0);
        C_Polyhedron ph(cs);

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

        GenSys gs;
        gs.insert(point(0*x + 0*y));
        gs.insert(point(0*x + y));
        gs.insert(ray(x - y));
        C_Polyhedron ph(gs);

Example 3
  The following code builds the polyhedron corresponding to an half-plane by adding a single constraint to the universe polyhedron in :

        C_Polyhedron ph(2);
        ph.add_constraint(y >= 0);

  The following code builds the same polyhedron as above, but starting from the empty polyhedron in the space and inserting the appropriate generators (a point, a ray and a line).

        C_Polyhedron ph(2, Polyhedron::EMPTY);
        ph.add_generator(point(0*x + 0*y));
        ph.add_generator(ray(y));
        ph.add_generator(line(x));

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

Example 4
  The following code shows the use of the function `add_dimensions_and_embed`:

        C_Polyhedron ph(1);
        ph.add_constraint(x == 2);
        ph.add_dimensions_and_embed(1);

  We build the universe polyhedron in the 1-dimension space . 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

Example 5
  The following code shows the use of the function `add_dimensions_and_project`:

        C_Polyhedron ph(1);
        ph.add_constraint(x == 2);
        ph.add_dimensions_and_project(1);

  The first two lines of code are the same as in Example 4 for `add_dimensions_and_embed`. After the last line of code, the resulting polyhedron is the singleton set .

Example 6
  The following code shows the use of the function `affine_image`:

        C_Polyhedron ph(2, Polyhedron::EMPTY);
        ph.add_generator(point(0*x + 0*y));
        ph.add_generator(point(0*x + 3*y));
        ph.add_generator(point(3*x + 0*y));
        ph.add_generator(point(3*x + 3*y));
        LinExpression coeff = x + 4;
        ph.affine_image(x, coeff);

  In this example the starting polyhedron is a square in , the considered variable is and the affine expression is . The resulting polyhedron is the same square translated to the right. Moreover, if the affine transformation for the same variable `x` is :

        LinExpression coeff = x + y;

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

        LinExpression coeff = y;

  the resulting polyhedron is a diagonal of the square.

Example 7
  The following code shows the use of the function `affine_preimage`:

        C_Polyhedron ph(2);
        ph.add_constraint(x >= 0);
        ph.add_constraint(x <= 3);
        ph.add_constraint(y >= 0);
        ph.add_constraint(y <= 3);
        LinExpression coeff = x + 4;
        ph.affine_preimage(x, coeff);

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

        LinExpression coeff = x + y;

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

        LinExpression coeff = y;

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

Example 8
  For this example we use also the variables:

        Variable z(2);
        Variable w(3);

  The following code shows the use of the function `remove_dimensions`:

        GenSys gs;
        gs.insert(point(3*x + y +0*z + 2*w));
        C_Polyhedron ph(gs);
        set<Variable> to_be_removed;
        to_be_removed.insert(y);
        to_be_removed.insert(z);
        ph.remove_dimensions(to_be_removed);

  The starting polyhedron is the singleton set , while the resulting polyhedron is . Be careful when removing dimensions incrementally: since dimensions are automatically renamed after each application of the `remove_dimensions` operator, unexpected results can be obtained. For instance, by using the following code we would obtain a different result:

        set<Variable> to_be_removed1;
        to_be_removed1.insert(y);
        ph.remove_dimensions(to_be_removed1);
        set<Variable> to_be_removed2;
        to_be_removed2.insert(z);
        ph.remove_dimensions(to_be_removed2);

  In this case, the result is the polyhedron : when removing the set of dimensions `to_be_removed2` we are actually removing variable of the original polyhedron. For the same reason, the operator `remove_dimensions` is not idempotent: removing twice the same set of dimensions is never a no-op.

## Member Enumeration Documentation

enum Parma_Polyhedra_Library::Polyhedron::Degenerate_Kind

  | Kinds of degenerate polyhedra. Enumeration values:
  UNIVERSE | The universe polyhedron, i.e., the whole vector space.
  EMPTY | The empty polyhedron, i.e., the empty set.

## Constructor & Destructor Documentation

Parma_Polyhedra_Library::Polyhedron::Polyhedron | ( | Topology | topol,
|  | dimension_type | num_dimensions,
|  | Degenerate_Kind | kind
| ) | `[protected]`

  | Builds a polyhedron having the specified properties. Parameters:
  | topol | The topology of the polyhedron;
  | num_dimensions | The number of dimensions of the vector space enclosing the polyhedron;
  | kind | Specifies whether the universe or the empty polyhedron has to be built.

Parma_Polyhedra_Library::Polyhedron::Polyhedron | ( | Topology | topol,
|  | const ConSys & | cs
| ) | `[protected]`

  | Builds a polyhedron from a system of constraints. The polyhedron inherits the space dimension of the constraint system. Parameters:
  | topol | The topology of the polyhedron;
  | cs | The system of constraints defining the polyhedron.
  Exceptions:
  | std::invalid_argument | Thrown if the topology of `cs` is incompatible with `topol`.

Parma_Polyhedra_Library::Polyhedron::Polyhedron | ( | Topology | topol,
|  | ConSys & | cs
| ) | `[protected]`

  | Builds a polyhedron recycling a system of constraints. The polyhedron inherits the space dimension of the constraint system. Parameters:
  | topol | The topology of the polyhedron;
  | cs | The system of constraints defining the polyhedron. It is not declared `const` because its data-structures will be recycled to build the polyhedron.
  Exceptions:
  | std::invalid_argument | Thrown if the topology of `cs` is incompatible with `topol`.

Parma_Polyhedra_Library::Polyhedron::Polyhedron | ( | Topology | topol,
|  | const GenSys & | gs
| ) | `[protected]`

  | Builds a polyhedron from a system of generators. The polyhedron inherits the space dimension of the generator system. Parameters:
  | topol | The topology of the polyhedron;
  | gs | The system of generators defining the polyhedron.
  Exceptions:
  | std::invalid_argument | Thrown if if the topology of `gs` is incompatible with `topol`, or if the system of generators is not empty but has no points.

Parma_Polyhedra_Library::Polyhedron::Polyhedron | ( | Topology | topol,
|  | GenSys & | gs
| ) | `[protected]`

  | Builds a polyhedron recycling a system of generators. The polyhedron inherits the space dimension of the generator system. Parameters:
  | topol | The topology of the polyhedron;
  | gs | The system of generators defining the polyhedron. It is not declared `const` because its data-structures will be recycled to build the polyhedron.
  Exceptions:
  | std::invalid_argument | Thrown if if the topology of `gs` is incompatible with `topol`, or if the system of generators is not empty but has no points.

template<typename Box>
Parma_Polyhedra_Library::Polyhedron::Polyhedron | ( | Topology | topol,
|  | const Box & | box
| ) | `[protected]`

  | Builds a polyhedron out of a generic, interval-based bounding box. Parameters:
  | topol | The topology of the polyhedron;
  | box | The bounding box representing the polyhedron to be built.
  Exceptions:
  | std::invalid_argument | Thrown if `box` has intervals that are incompatible with `topol`.
The template class Box must provide the following methods.
          dimension_type space_dimension() const
returns the dimension of the vector space enclosing the polyhedron represented by the bounding box.
          bool is_empty() const
returns `true` if and only if the bounding box describes the empty set. The `is_empty()` method will always be called before the methods below. However, if `is_empty()` returns `true`, none of the functions below will be called.
          bool get_lower_bound(dimension_type k, bool closed,
                               Integer& n, Integer& d) const
Let the interval corresponding to the `k`-th dimension. If is not bounded from below, simply return `false`. Otherwise, set `closed`, `n` and `d` as follows: `closed` is set to `true` if the the lower boundary of is closed and is set to `false` otherwise; `n` and `d` are assigned the integers and such that the canonical fraction corresponds to the greatest lower bound of . The fraction is in canonical form if and only if and have no common factors and is positive, being the unique representation for zero.
          bool get_upper_bound(dimension_type k, bool closed,
                               Integer& n, Integer& d) const
Let the interval corresponding to the `k`-th dimension. If is not bounded from above, simply return `false`. Otherwise, set `closed`, `n` and `d` as follows: `closed` is set to `true` if the the upper boundary of is closed and is set to `false` otherwise; `n` and `d` are assigned the integers and such that the canonical fraction corresponds to the least upper bound of .

## Member Function Documentation

Poly_Con_Relation Parma_Polyhedra_Library::Polyhedron::relation_with | ( | const Constraint & | c | ) | const

  | Returns the relations holding between the polyhedron `*this` and the constraint `c`. Exceptions:
  | std::invalid_argument | Thrown if `*this` and constraint `c` are dimension-incompatible.

Poly_Gen_Relation Parma_Polyhedra_Library::Polyhedron::relation_with | ( | const Generator & | g | ) | const

  | Returns the relations holding between the polyhedron `*this` and the generator `g`. Exceptions:
  | std::invalid_argument | Thrown if `*this` and generator `g` are dimension-incompatible.

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

  | Returns `true` if and only if `*this` and `y` are disjoint. Exceptions:
  | std::invalid_argument | Thrown if `x` and `y` are topology-incompatible or dimension-incompatible.

bool Parma_Polyhedra_Library::Polyhedron::bounds_from_above | ( | const LinExpression & | expr | ) | const

  | Returns `true` if and only if `expr` is bounded from above in `*this`. Exceptions:
  | std::invalid_argument | Thrown if `expr` and `*this` are dimension-incompatible.

bool Parma_Polyhedra_Library::Polyhedron::bounds_from_below | ( | const LinExpression & | expr | ) | const

  | Returns `true` if and only if `expr` is bounded from below in `*this`. Exceptions:
  | std::invalid_argument | Thrown if `expr` and `*this` are dimension-incompatible.

bool Parma_Polyhedra_Library::Polyhedron::maximize | ( | const LinExpression & | expr,
|  | Integer & | sup_n,
|  | Integer & | 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. Parameters:
  | expr | The linear expression to be maximized subject to `*this`;
  | sup_n | The numerator of the supremum value;
  | sup_d | The denominator of the supremum value;
  | maximum | `true` if and only if the supremum is also the maximum value.
  Exceptions:
  | std::invalid_argument | Thrown if `expr` and `*this` are dimension-incompatible.
If `*this` is empty or `expr` is not bounded from above, `false` is returned and `sup_n`, `sup_d` and `maximum` are left untouched.

bool Parma_Polyhedra_Library::Polyhedron::maximize | ( | const LinExpression & | expr,
|  | Integer & | sup_n,
|  | Integer & | sup_d,
|  | bool & | maximum,
|  | const Generator **const | pppoint
| ) | 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. Parameters:
  | expr | The linear expression to be maximized subject to `*this`;
  | sup_n | The numerator of the supremum value;
  | sup_d | The denominator of the supremum value;
  | maximum | `true` if and only if the supremum is also the maximum value;
  | pppoint | When nonzero and maximization succeeds, a pointer to a point or closure point where `expr` reaches its supremum value will be written at this address.
  Exceptions:
  | std::invalid_argument | Thrown if `expr` and `*this` are dimension-incompatible.
If `*this` is empty or `expr` is not bounded from above, `false` is returned and `sup_n`, `sup_d`, `maximum` and `pppoint` are left untouched.

bool Parma_Polyhedra_Library::Polyhedron::minimize | ( | const LinExpression & | expr,
|  | Integer & | inf_n,
|  | Integer & | 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. Parameters:
  | expr | The linear expression to be minimized subject to `*this`;
  | inf_n | The numerator of the infimum value;
  | inf_d | The denominator of the infimum value;
  | minimum | `true` if and only if the infimum is also the minimum value.
  Exceptions:
  | std::invalid_argument | Thrown if `expr` and `*this` are dimension-incompatible.
If `*this` is empty or `expr` is not bounded from below, `false` is returned and `inf_n`, `inf_d` and `minimum` are left untouched.

bool Parma_Polyhedra_Library::Polyhedron::minimize | ( | const LinExpression & | expr,
|  | Integer & | inf_n,
|  | Integer & | inf_d,
|  | bool & | minimum,
|  | const Generator **const | pppoint
| ) | 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. Parameters:
  | expr | The linear expression to be minimized subject to `*this`;
  | inf_n | The numerator of the infimum value;
  | inf_d | The denominator of the infimum value;
  | minimum | `true` if and only if the infimum is also the minimum value;
  | pppoint | When nonzero and minimization succeeds, a pointer to a point or closure point where `expr` reaches its infimum value will be written at this address.
  Exceptions:
  | std::invalid_argument | Thrown if `expr` and `*this` are dimension-incompatible.
If `*this` is empty or `expr` is not bounded from below, `false` is returned and `inf_n`, `inf_d`, `minimum` and `pppoint` are left untouched.

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

  | Returns `true` if and only if `*this` contains `y`. Exceptions:
  | std::invalid_argument | Thrown if `*this` and `y` are topology-incompatible or dimension-incompatible.

bool Parma_Polyhedra_Library::Polyhedron::strictly_contains | ( | const Polyhedron & | y | ) | const

  | Returns `true` if and only if `*this` strictly contains `y`. Exceptions:
  | std::invalid_argument | Thrown if `*this` and `y` are topology-incompatible or dimension-incompatible.

template<typename Box>
void Parma_Polyhedra_Library::Polyhedron::shrink_bounding_box | ( | Box & | box,
|  | Complexity_Class | complexity = `ANY`
| ) | const

  | Uses `*this` to shrink a generic, interval-based bounding box. Parameters:
  | box | The bounding box to be shrunk;
  | complexity | The complexity class of the algorithm to be used.
The template class Box must provide the following methods, whose return value, if any, is simply ignored.
          set_empty()
causes the box to become empty, i.e., to represent the empty set.
          raise_lower_bound(dimension_type k, bool closed,
                            const Integer& n, const Integer& d)
intersects the interval corresponding to the `k`-th dimension with if `closed` is `true`, with if `closed` is `false`.
          lower_upper_bound(dimension_type k, bool closed,
                            const Integer& n, const Integer& d)
intersects the interval corresponding to the `k`-th dimension with if `closed` is `true`, with if `closed` is `false`. The function `raise_lower_bound(k, closed, n, d)` will be called at most once for each possible value for `k` and for all such calls the fraction will be in canonical form, that is, and have no common factors and is positive, being the unique representation for zero. The same guarantee is offered for the function `lower_upper_bound(k, closed, n, d)`.

bool Parma_Polyhedra_Library::Polyhedron::OK | ( | bool | check_not_empty = `false` | ) | const

  | Checks if all the invariants are satisfied. Returns: `true` if and only if `*this` satisfies all the invariants and either `check_not_empty` is `false` or `*this` is not empty. Parameters:
  | check_not_empty | `true` if and only if, in addition to checking the invariants, `*this` must be checked to be not empty.
The check is performed so as to intrude as little as possible. If the library has been compiled with run-time assertions enabled, error messages are written on `std::cerr` in case invariants are violated. This is useful for the purpose of debugging the library.

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). Exceptions:
  | std::invalid_argument | Thrown if `*this` and constraint `c` are topology-incompatible or dimension-incompatible.

bool Parma_Polyhedra_Library::Polyhedron::add_constraint_and_minimize | ( | const Constraint & | c | ) |

  | Adds a copy of constraint `c` to the system of constraints of `*this`, minimizing the result. Returns: `false` if and only if the result is empty. Exceptions:
  | std::invalid_argument | Thrown if `*this` and constraint `c` are 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). Exceptions:
  | std::invalid_argument | Thrown if `*this` and generator `g` are topology-incompatible or dimension-incompatible, or if `*this` is an empty polyhedron and `g` is not a point.

bool Parma_Polyhedra_Library::Polyhedron::add_generator_and_minimize | ( | const Generator & | g | ) |

  | Adds a copy of generator `g` to the system of generators of `*this`, minimizing the result. Returns: `false` if and only if the result is empty. Exceptions:
  | std::invalid_argument | Thrown if `*this` and generator `g` are topology-incompatible or dimension-incompatible, or if `*this` is an empty polyhedron and `g` is not a point.

void Parma_Polyhedra_Library::Polyhedron::add_constraints | ( | const ConSys & | cs | ) |

  | Adds a copy of the constraints in `cs` to the system of constraints of `*this` (without minimizing the result). Parameters:
  | cs | Contains the constraints that will be added to the system of constraints of `*this`.
  Exceptions:
  | std::invalid_argument | Thrown if `*this` and `cs` are topology-incompatible or dimension-incompatible.

void Parma_Polyhedra_Library::Polyhedron::add_recycled_constraints | ( | ConSys & | cs | ) |

  | Adds the constraints in `cs` to the system of constraints of `*this` (without minimizing the result). Parameters:
  | cs | The constraint system that will be recycled, adding its constraints to the system of constraints of `*this`.
  Exceptions:
  | std::invalid_argument | Thrown if `*this` and `cs` are topology-incompatible or dimension-incompatible.
Warning: The only assumption that can be made on `cs` upon successful or exceptional return is that it can be safely destroyed.

bool Parma_Polyhedra_Library::Polyhedron::add_constraints_and_minimize | ( | const ConSys & | cs | ) |

  | Adds a copy of the constraints in `cs` to the system of constraints of `*this`, minimizing the result. Returns: `false` if and only if the result is empty. Parameters:
  | cs | Contains the constraints that will be added to the system of constraints of `*this`.
  Exceptions:
  | std::invalid_argument | Thrown if `*this` and `cs` are topology-incompatible or dimension-incompatible.

bool Parma_Polyhedra_Library::Polyhedron::add_recycled_constraints_and_minimize | ( | ConSys & | cs | ) |

  | Adds the constraints in `cs` to the system of constraints of `*this`, minimizing the result. Returns: `false` if and only if the result is empty. Parameters:
  | cs | The constraint system that will be recycled, adding its constraints to the system of constraints of `*this`.
  Exceptions:
  | std::invalid_argument | Thrown if `*this` and `cs` are topology-incompatible or dimension-incompatible.
Warning: The only assumption that can be made on `cs` upon successful or exceptional return is that it can be safely destroyed.

void Parma_Polyhedra_Library::Polyhedron::add_generators | ( | const GenSys & | gs | ) |

  | Adds a copy of the generators in `gs` to the system of generators of `*this` (without minimizing the result). Parameters:
  | gs | Contains the generators that will be added to the system of generators of `*this`.
  Exceptions:
  | std::invalid_argument | Thrown if `*this` and `gs` are topology-incompatible or dimension-incompatible, or if `*this` is empty and the system of generators `gs` is not empty, but has no points.

void Parma_Polyhedra_Library::Polyhedron::add_recycled_generators | ( | GenSys & | gs | ) |

  | Adds the generators in `gs` to the system of generators of `*this` (without minimizing the result). Parameters:
  | gs | The generator system that will be recycled, adding its generators to the system of generators of `*this`.
  Exceptions:
  | std::invalid_argument | Thrown if `*this` and `gs` are topology-incompatible or dimension-incompatible, or if `*this` is empty and the system of generators `gs` is not empty, but has no points.
Warning: The only assumption that can be made on `gs` upon successful or exceptional return is that it can be safely destroyed.

bool Parma_Polyhedra_Library::Polyhedron::add_generators_and_minimize | ( | const GenSys & | gs | ) |

  | Adds a copy of the generators in `gs` to the system of generators of `*this`, minimizing the result. Returns: `false` if and only if the result is empty. Parameters:
  | gs | Contains the generators that will be added to the system of generators of `*this`.
  Exceptions:
  | std::invalid_argument | Thrown if `*this` and `gs` are topology-incompatible or dimension-incompatible, or if `*this` is empty and the the system of generators `gs` is not empty, but has no points.

bool Parma_Polyhedra_Library::Polyhedron::add_recycled_generators_and_minimize | ( | GenSys & | gs | ) |

  | Adds the generators in `gs` to the system of generators of `*this`, minimizing the result. Returns: `false` if and only if the result is empty. Parameters:
  | gs | The generator system that will be recycled, adding its generators to the system of generators of `*this`.
  Exceptions:
  | std::invalid_argument | Thrown if `*this` and `gs` are topology-incompatible or dimension-incompatible, or if `*this` is empty and the the system of generators `gs` is not empty, but has no points.
Warning: The only assumption that can be made on `gs` upon successful or exceptional return is that it can be safely destroyed.

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

  | Assigns to `*this` the intersection of `*this` and `y`. The result is not guaranteed to be minimized. Exceptions:
  | std::invalid_argument | Thrown if `*this` and `y` are topology-incompatible or dimension-incompatible.

bool Parma_Polyhedra_Library::Polyhedron::intersection_assign_and_minimize | ( | const Polyhedron & | y | ) |

  | Assigns to `*this` the intersection of `*this` and `y`, minimizing the result. Returns: `false` if and only if the result is empty. Exceptions:
  | std::invalid_argument | Thrown if `*this` and `y` are 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`. The result is not guaranteed to be minimized. Exceptions:
  | std::invalid_argument | Thrown if `*this` and `y` are topology-incompatible or dimension-incompatible.

bool Parma_Polyhedra_Library::Polyhedron::poly_hull_assign_and_minimize | ( | const Polyhedron & | y | ) |

  | Assigns to `*this` the poly-hull of `*this` and `y`, minimizing the result. Returns: `false` if and only if the result is empty. Exceptions:
  | std::invalid_argument | Thrown if `*this` and `y` are 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`. The result is not guaranteed to be minimized. Exceptions:
  | std::invalid_argument | Thrown if `*this` and `y` are topology-incompatible or dimension-incompatible.

void Parma_Polyhedra_Library::Polyhedron::affine_image | ( | Variable | var,
|  | const LinExpression & | expr,
|  | const Integer & | denominator = `Integer_one()`
| ) |

  | Assigns to `*this` the affine image of `*this` under the function mapping variable `var` to the affine expression specified by `expr` and `denominator`. Parameters:
  | var | The variable to which the affine expression is assigned;
  | expr | The numerator of the affine expression;
  | denominator | The denominator of the affine expression (optional argument with default value 1.)
  Exceptions:
  | std::invalid_argument | Thrown if `denominator` is zero or if `expr` and `*this` are dimension-incompatible or if `var` is not a dimension of `this`.

void Parma_Polyhedra_Library::Polyhedron::affine_preimage | ( | Variable | var,
|  | const LinExpression & | expr,
|  | const Integer & | denominator = `Integer_one()`
| ) |

  | Assigns to `*this` the affine preimage of `*this` under the function mapping variable `var` to the affine expression specified by `expr` and `denominator`. Parameters:
  | var | The variable to which the affine expression is substituted;
  | expr | The numerator of the affine expression;
  | denominator | The denominator of the affine expression (optional argument with default value 1.)
  Exceptions:
  | std::invalid_argument | Thrown if `denominator` is zero or if `expr` and `*this` are dimension-incompatible or if `var` is not a dimension of `*this`.

void Parma_Polyhedra_Library::Polyhedron::generalized_affine_image | ( | Variable | var,
|  | const Relation_Symbol | relsym,
|  | const LinExpression & | expr,
|  | const Integer & | denominator = `Integer_one()`
| ) |

  | Assigns to `*this` the image of `*this` with respect to the generalized affine transfer function , where is the relation symbol encoded by `relsym`. Parameters:
  | var | The left hand side variable of the generalized affine transfer function;
  | relsym | The relation symbol;
  | expr | The numerator of the right hand side affine expression;
  | denominator | The denominator of the right hand side affine expression (optional argument with default value 1.)
  Exceptions:
  | std::invalid_argument | Thrown if `denominator` is zero or if `expr` and `*this` are dimension-incompatible or if `var` is not a dimension of `*this` or if `*this` is a C_Polyhedron and `relsym` is a strict relation symbol.

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

  | Assigns to `*this` the image of `*this` with respect to the generalized affine transfer function , where is the relation symbol encoded by `relsym`. Parameters:
  | lhs | The left hand side affine expression;
  | relsym | The relation symbol;
  | rhs | The right hand side affine expression.
  Exceptions:
  | std::invalid_argument | Thrown if `*this` is dimension-incompatible with `lhs` or `rhs` or if `*this` is a C_Polyhedron and `relsym` is a strict relation symbol.

void Parma_Polyhedra_Library::Polyhedron::time_elapse_assign | ( | const Polyhedron & | y | ) |

  | Assigns to `*this` the result of computing the time-elapse between `*this` and `y`. Exceptions:
  | std::invalid_argument | Thrown if `*this` and `y` are topology-incompatible or dimension-incompatible.

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

  | Assigns to `*this` the result of computing the BHRZ03-widening between `*this` and `y`. Parameters:
  | y | A polyhedron that must be contained in `*this`;
  | tp | An optional pointer to an unsigned variable storing the number of available tokens (to be used when applying the widening with tokens delay technique).
  Exceptions:
  | std::invalid_argument | Thrown if `*this` and `y` are topology-incompatible or dimension-incompatible.

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

  | Improves the result of the BHRZ03-widening computation by also enforcing those constraints in `cs` that are satisfied by all the points of `*this`. Parameters:
  | y | A polyhedron that must be contained in `*this`;
  | cs | The system of constraints used to improve the widened polyhedron;
  | tp | An optional pointer to an unsigned variable storing the number of available tokens (to be used when applying the widening with tokens delay technique).
  Exceptions:
  | std::invalid_argument | Thrown if `*this`, `y` and `cs` are topology-incompatible or dimension-incompatible.

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

  | Improves the result of the BHRZ03-widening computation by also enforcing those constraints in `cs` that are satisfied by all the points of `*this`, plus all the constraints of the form and , with , that are satisfied by all the points of `*this`. Parameters:
  | y | A polyhedron that must be contained in `*this`;
  | cs | The system of constraints used to improve the widened polyhedron;
  | tp | An optional pointer to an unsigned variable storing the number of available tokens (to be used when applying the widening with tokens delay technique).
  Exceptions:
  | std::invalid_argument | Thrown if `*this`, `y` and `cs` are topology-incompatible or dimension-incompatible.

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

  | Assigns to `*this` the result of computing the H79-widening between `*this` and `y`. Parameters:
  | y | A polyhedron that must be contained in `*this`;
  | tp | An optional pointer to an unsigned variable storing the number of available tokens (to be used when applying the widening with tokens delay technique).
  Exceptions:
  | std::invalid_argument | Thrown if `*this` and `y` are topology-incompatible or dimension-incompatible.

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

  | Improves the result of the H79-widening computation by also enforcing those constraints in `cs` that are satisfied by all the points of `*this`. Parameters:
  | y | A polyhedron that must be contained in `*this`;
  | cs | The system of constraints used to improve the widened polyhedron;
  | tp | An optional pointer to an unsigned variable storing the number of available tokens (to be used when applying the widening with tokens delay technique).
  Exceptions:
  | std::invalid_argument | Thrown if `*this`, `y` and `cs` are topology-incompatible or dimension-incompatible.

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

  | Improves the result of the H79-widening computation by also enforcing those constraints in `cs` that are satisfied by all the points of `*this`, plus all the constraints of the form and , with , that are satisfied by all the points of `*this`. Parameters:
  | y | A polyhedron that must be contained in `*this`;
  | cs | The system of constraints used to improve the widened polyhedron;
  | tp | An optional pointer to an unsigned variable storing the number of available tokens (to be used when applying the widening with tokens delay technique).
  Exceptions:
  | std::invalid_argument | Thrown if `*this`, `y` and `cs` are topology-incompatible or dimension-incompatible.

void Parma_Polyhedra_Library::Polyhedron::add_dimensions_and_embed | ( | dimension_type | m | ) |

  | Adds `m` new dimensions and embeds the old polyhedron in the new space. Parameters:
  | m | The number of dimensions to add.
The new 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 dimension, the result will be the polyhedron

void Parma_Polyhedra_Library::Polyhedron::add_dimensions_and_project | ( | dimension_type | m | ) |

  | Adds `m` new dimensions to the polyhedron and does not embed it in the new space. Parameters:
  | m | The number of dimensions to add.
The new 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 dimension, the result will be the polyhedron

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

  | Assigns to `*this` the concatenation of `*this` and `y`, taken in this order. Exceptions:
  | std::invalid_argument | Thrown if `*this` and `y` are topology-incompatible.

void Parma_Polyhedra_Library::Polyhedron::remove_dimensions | ( | const Variables_Set & | to_be_removed | ) |

  | Removes all the specified dimensions. Parameters:
  | to_be_removed | The set of Variable objects corresponding to the dimensions to be removed.
  Exceptions:
  | std::invalid_argument | Thrown if `*this` is dimension-incompatible with one of the Variable objects contained in `to_be_removed`.

void Parma_Polyhedra_Library::Polyhedron::remove_higher_dimensions | ( | dimension_type | new_dimension | ) |

  | Removes the higher dimensions so that the resulting space will have dimension `new_dimension`. Exceptions:
  | std::invalid_argument | Thrown if `new_dimensions` is greater than the space dimension of `*this`.

template<typename PartialFunction>
void Parma_Polyhedra_Library::Polyhedron::map_dimensions | ( | const PartialFunction & | pfunc | ) |

  | Remaps the dimensions of the vector space according to a partial function. Parameters:
  | pfunc | The partial function specifying the destiny of each dimension.
The template class PartialFunction must provide the following methods.
          bool has_empty_codomain() const
returns `true` if and only if the represented partial function has an empty codomain (i.e., it is always undefined). The `has_empty_codomain()` method will always be called before the methods below. However, if `has_empty_codomain()` returns `true`, none of the functions below will be called.
          dimension_type max_in_codomain() const
returns the maximum value that belongs to the codomain of the partial function. The `max_in_codomain()` method is called at most once.
          bool maps(dimension_type i, dimension_type& j) const
Let be the represented function and be the value of `i`. If is defined in , then is assigned to `j` and `true` is returned. If is undefined in , then `false` is returned. This method is called at most times, where 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_dimension | ( | Variable | var,
|  | dimension_type | m
| ) |

  | Creates `m` copies of the dimension corresponding to `var`. Parameters:
  | var | The variable corresponding to the dimension to be replicated;
  | m | The number of replica to be created.
  Exceptions:
  | std::invalid_argument | Thrown if `var` does not correspond to a dimension of the polyhedron.
If `*this` is -dimensional, with , and is `var.id()`, then the -th dimension is expanded to `m` new dimensions , , , .

void Parma_Polyhedra_Library::Polyhedron::fold_dimensions | ( | const Variables_Set & | to_be_folded,
|  | Variable | var
| ) |

  | Folds the dimensions in `to_be_folded` into `var`. Parameters:
  | to_be_folded | The set of Variable objects corresponding to the dimensions to be folded;
  | var | The variable corresponding to the dimension that is the destination of the folding operation.
  Exceptions:
  | 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`.
If `*this` is -dimensional, with , is `var.id()`, `to_be_folded` is a set of variables whose `id()` is also less than , and `var` is not a member of `to_be_folded`, then the dimensions corresponding to variables in `to_be_folded` are folded into dimension .

void Parma_Polyhedra_Library::Polyhedron::swap | ( | Polyhedron & | y | ) |

  | Swaps `*this` with polyhedron `y`. (`*this` and `y` can be dimension-incompatible.). Exceptions:
  | std::invalid_argument | Thrown if `x` and `y` are topology-incompatible.

## Friends And Related Function Documentation

std::ostream & operator<< | ( | std::ostream & | s,
|  | const Polyhedron & | ph
| ) | `[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 ", ".

bool operator== | ( | const Polyhedron & | x,
|  | const Polyhedron & | 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.

bool operator!= | ( | const Polyhedron & | x,
|  | const Polyhedron & | y
| ) | `[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.