# Parma_Polyhedra_Library::Box< ITV > Class Template Reference
[C++ Language Interface]

A not necessarily closed, iso-oriented hyperrectangle. More...

`#include <ppl.hh>`

List of all members.

## Public Types
typedef ITV | interval_type
| The type of intervals used to implement the box.
## Public Member Functions
const ITV & | get_interval (Variable var) const
| Returns a reference the interval that bounds `var`.
void | set_interval (Variable var, const ITV &i)
| Sets to `i` the interval that bounds `var`.
bool | get_lower_bound (dimension_type k, bool &closed, Coefficient &n, Coefficient &d) const
| If the `k`-th space dimension is unbounded below, returns `false`. Otherwise returns `true` and set `closed`, `n` and `d` accordingly.
bool | get_upper_bound (dimension_type k, bool &closed, Coefficient &n, Coefficient &d) const
| If the `k`-th space dimension is unbounded above, returns `false`. Otherwise returns `true` and set `closed`, `n` and `d` accordingly.
Constraint_System | constraints () const
| Returns a system of constraints defining `*this`.
Constraint_System | minimized_constraints () const
| Returns a minimized system of constraints defining `*this`.
Congruence_System | congruences () const
| Returns a system of congruences approximating `*this`.
Congruence_System | minimized_congruences () const
| Returns a minimized system of congruences approximating `*this`.
memory_size_type | total_memory_in_bytes () const
| Returns the total size in bytes of the memory occupied by `*this`.
memory_size_type | external_memory_in_bytes () const
| Returns the size in bytes of the memory managed by `*this`.
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<<`.
void | set_empty ()
| Causes the box to become empty, i.e., to represent the empty set.
Constructors, Assignment, Swap and Destructor
| Box (dimension_type num_dimensions=0, Degenerate_Element kind=UNIVERSE)
| Builds a universe or empty box of the specified space dimension.
| Box (const Box &y, Complexity_Class complexity=ANY_COMPLEXITY)
| Ordinary copy-constructor.
template<typename Other_ITV >
| Box (const Box< Other_ITV > &y, Complexity_Class complexity=ANY_COMPLEXITY)
| Builds a conservative, upward approximation of `y`.
| Box (const Constraint_System &cs)
| Builds a box from the system of constraints `cs`.
| Box (const Constraint_System &cs, Recycle_Input dummy)
| Builds a box recycling a system of constraints `cs`.
| Box (const Generator_System &gs)
| Builds a box from the system of generators `gs`.
| Box (const Generator_System &gs, Recycle_Input dummy)
| Builds a box recycling the system of generators `gs`.
| Box (const Congruence_System &cgs)
| Box (const Congruence_System &cgs, Recycle_Input dummy)
template<typename T >
| Box (const BD_Shape< T > &bds, Complexity_Class complexity=POLYNOMIAL_COMPLEXITY)
| Builds a box containing the BDS `bds`.
template<typename T >
| Box (const Octagonal_Shape< T > &oct, Complexity_Class complexity=POLYNOMIAL_COMPLEXITY)
| Builds a box containing the octagonal shape `oct`.
| Box (const Polyhedron &ph, Complexity_Class complexity=ANY_COMPLEXITY)
| Builds a box containing the polyhedron `ph`.
| Box (const Grid &ph, Complexity_Class complexity=POLYNOMIAL_COMPLEXITY)
| Builds a box containing the grid `gr`.
template<typename D1 , typename D2 , typename R >
| Box (const Partially_Reduced_Product< D1, D2, R > &dp, Complexity_Class complexity=ANY_COMPLEXITY)
| Builds a box containing the partially reduced product `dp`.
Box & | operator= (const Box &y)
| The assignment operator (`*this` and `y` can be dimension-incompatible).
void | swap (Box &y)
| Swaps `*this` with `y` (`*this` and `y` can be dimension-incompatible).
Member Functions that Do Not Modify the Box
dimension_type | space_dimension () const
| Returns the dimension of the vector space enclosing `*this`.
dimension_type | affine_dimension () const
| Returns , if `*this` is empty; otherwise, returns the affine dimension of `*this`.
bool | is_empty () const
| Returns `true` if and only if `*this` is an empty box.
bool | is_universe () const
| Returns `true` if and only if `*this` is a universe box.
bool | is_topologically_closed () const
| Returns `true` if and only if `*this` is a topologically closed subset of the vector space.
bool | is_discrete () const
| Returns `true` if and only if `*this` is discrete.
bool | is_bounded () const
| Returns `true` if and only if `*this` is a bounded box.
bool | contains_integer_point () const
| Returns `true` if and only if `*this` contains at least one integer point.
bool | constrains (Variable var) const
| Returns `true` if and only if `var` is constrained in `*this`.
Poly_Con_Relation | relation_with (const Constraint &c) const
| Returns the relations holding between `*this` and the constraint `c`.
Poly_Con_Relation | relation_with (const Congruence &cg) const
| Returns the relations holding between `*this` and the congruence `cg`.
Poly_Gen_Relation | relation_with (const Generator &g) const
| Returns the relations holding between `*this` and the generator `g`.
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 | contains (const Box &) const
| Returns `true` if and only if `*this` contains `y`.
bool | strictly_contains (const Box &) const
| Returns `true` if and only if `*this` strictly contains `y`.
bool | is_disjoint_from (const Box &y) const
| Returns `true` if and only if `*this` and `y` are disjoint.
bool | OK () const
| Returns `true` if and only if `*this` satisfies all its invariants.
Space-Dimension Preserving Member Functions that May Modify the Box
void | add_constraint (const Constraint &c)
| Adds a copy of constraint `c` to the system of constraints defining `*this`.
void | add_constraints (const Constraint_System &cs)
| Adds the constraints in `cs` to the system of constraints defining `*this`.
void | add_recycled_constraints (Constraint_System &cs)
| Adds the constraints in `cs` to the system of constraints defining `*this`.
void | add_congruence (const Congruence &cg)
| Adds to `*this` a constraint equivalent to the congruence `cg`.
void | add_congruences (const Congruence_System &cgs)
| Adds to `*this` constraints equivalent to the congruences in `cgs`.
void | add_recycled_congruences (Congruence_System &cgs)
| Adds to `*this` constraints equivalent to the congruences in `cgs`.
void | refine_with_constraint (const Constraint &c)
| Use the constraint `c` to refine `*this`.
void | refine_with_constraints (const Constraint_System &cs)
| Use the constraints in `cs` to refine `*this`.
void | refine_with_congruence (const Congruence &cg)
| Use the congruence `cg` to refine `*this`.
void | refine_with_congruences (const Congruence_System &cgs)
| Use the congruences in `cgs` to refine `*this`.
void | propagate_constraint (const Constraint &c)
| Use the constraint `c` for constraint propagation on `*this`.
void | propagate_constraints (const Constraint_System &cs)
| Use the constraints in `cs` for constraint propagagion on `*this`.
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 | intersection_assign (const Box &y)
| Assigns to `*this` the intersection of `*this` and `y`.
void | upper_bound_assign (const Box &y)
| Assigns to `*this` the smallest box containing the union of `*this` and `y`.
bool | upper_bound_assign_if_exact (const Box &y)
| If the upper bound of `*this` and `y` is exact, it is assigned to `*this` and `true` is returned, otherwise `false` is returned.
void | difference_assign (const Box &y)
| Assigns to `*this` the difference of `*this` and `y`.
bool | simplify_using_context_assign (const Box &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 Box &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 | CC76_widening_assign (const Box &y, unsigned *tp=0)
| Assigns to `*this` the result of computing the CC76-widening between `*this` and `y`.
template<typename Iterator >
void | CC76_widening_assign (const Box &y, Iterator first, Iterator last)
| Assigns to `*this` the result of computing the CC76-widening between `*this` and `y`.
void | widening_assign (const Box &y, unsigned *tp=0)
| Same as CC76_widening_assign(y, tp).
void | limited_CC76_extrapolation_assign (const Box &y, const Constraint_System &cs, unsigned *tp=0)
| Improves the result of the CC76-extrapolation computation by also enforcing those constraints in `cs` that are satisfied by all the points of `*this`.
void | CC76_narrowing_assign (const Box &y)
| Assigns to `*this` the result of restoring in `y` the constraints of `*this` that were lost by CC76-extrapolation applications.
Member Functions that May Modify the Dimension of the Vector Space
void | add_space_dimensions_and_embed (dimension_type m)
| Adds `m` new dimensions and embeds the old box into the new space.
void | add_space_dimensions_and_project (dimension_type m)
| Adds `m` new dimensions to the box and does not embed it in the new vector space.
void | concatenate_assign (const Box &y)
| Seeing a box as a set of tuples (its points), assigns to `*this` all the tuples that can be obtained by concatenating, in the order given, a tuple of `*this` with a tuple of `y`.
void | remove_space_dimensions (const Variables_Set &to_be_removed)
| Removes all the specified dimensions.
void | remove_higher_space_dimensions (dimension_type new_dimension)
| Removes the higher 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 that a Box can handle.
static bool | can_recycle_constraint_systems ()
| Returns false indicating that this domain does not recycle constraints.
static bool | can_recycle_congruence_systems ()
| Returns false indicating that this domain does not recycle congruences.
## Friends
bool | operator== (const Box< ITV > &x, const Box< ITV > &y)
| Returns `true` if and only if `x` and `y` are the same box.
## Related Functions
(Note that these are not member functions.)
template<typename ITV >
bool | operator!= (const Box< ITV > &x, const Box< ITV > &y)
| Returns `true` if and only if `x` and `y` aren't the same box.
template<typename ITV >
std::ostream & | operator<< (std::ostream &s, const Box< ITV > &box)
| Output operator.
template<typename To , typename ITV >
bool | rectilinear_distance_assign (Checked_Number< To, Extended_Number_Policy > &r, const Box< ITV > &x, const Box< ITV > &y, Rounding_Dir dir)
| Computes the rectilinear (or Manhattan) distance between `x` and `y`.
template<typename Temp , typename To , typename ITV >
bool | rectilinear_distance_assign (Checked_Number< To, Extended_Number_Policy > &r, const Box< ITV > &x, const Box< ITV > &y, Rounding_Dir dir, Temp &tmp0, Temp &tmp1, Temp &tmp2)
| Computes the rectilinear (or Manhattan) distance between `x` and `y`.
template<typename To , typename ITV >
bool | euclidean_distance_assign (Checked_Number< To, Extended_Number_Policy > &r, const Box< ITV > &x, const Box< ITV > &y, Rounding_Dir dir)
| Computes the euclidean distance between `x` and `y`.
template<typename Temp , typename To , typename ITV >
bool | euclidean_distance_assign (Checked_Number< To, Extended_Number_Policy > &r, const Box< ITV > &x, const Box< ITV > &y, Rounding_Dir dir, Temp &tmp0, Temp &tmp1, Temp &tmp2)
| Computes the euclidean distance between `x` and `y`.
template<typename To , typename ITV >
bool | l_infinity_distance_assign (Checked_Number< To, Extended_Number_Policy > &r, const Box< ITV > &x, const Box< ITV > &y, Rounding_Dir dir)
| Computes the distance between `x` and `y`.
template<typename Temp , typename To , typename ITV >
bool | l_infinity_distance_assign (Checked_Number< To, Extended_Number_Policy > &r, const Box< ITV > &x, const Box< ITV > &y, Rounding_Dir dir, Temp &tmp0, Temp &tmp1, Temp &tmp2)
| Computes the distance between `x` and `y`.

## Detailed Description

### template<typename ITV>
class Parma_Polyhedra_Library::Box< ITV >

A not necessarily closed, iso-oriented hyperrectangle.

A Box object represents the smash product of not necessarily closed and possibly unbounded intervals represented by objects of class `ITV`, where is the space dimension of the box.

An interval constraint (resp., interval congruence) is a syntactic constraint (resp., congruence) that only mentions a single space dimension.

The Box domain optimally supports:

- tautological and inconsistent constraints and congruences;
- the interval constraints that are optimally supported by the template argument class `ITV`;
- the interval congruences that are optimally supported by the template argument class `ITV`.

Depending on the method, using a constraint or congruence that is not optimally supported by the domain will either raise an exception or result in a (possibly non-optimal) upward approximation.

The user interface for the Box domain is meant to be as similar as possible to the one developed for the polyhedron class C_Polyhedron.

## Constructor & Destructor Documentation

template<typename ITV >

Parma_Polyhedra_Library::Box< ITV >::Box | ( | dimension_type | num_dimensions = `0`,
|  | Degenerate_Element | kind = `UNIVERSE` |
| ) |  |  | `[inline, explicit]`

Builds a universe or empty box of the specified space dimension.

Parameters:

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

template<typename ITV >

Parma_Polyhedra_Library::Box< ITV >::Box | ( | const Box< ITV > & | y,
|  | Complexity_Class | complexity = `ANY_COMPLEXITY` |
| ) |  |  | `[inline]`

Ordinary copy-constructor.

The complexity argument is ignored.

template<typename ITV >
template<typename Other_ITV >

Parma_Polyhedra_Library::Box< ITV >::Box | ( | const Box< Other_ITV > & | y,
|  | Complexity_Class | complexity = `ANY_COMPLEXITY` |
| ) |  |  | `[inline, explicit]`

Builds a conservative, upward approximation of `y`.

The complexity argument is ignored.

template<typename ITV >

Parma_Polyhedra_Library::Box< ITV >::Box | ( | const Constraint_System & | cs | ) | `[inline, explicit]`

Builds a box from the system of constraints `cs`.

The box inherits the space dimension of `cs`.

Parameters:

  | cs | A system of constraints: constraints that are not interval constraints are ignored (even though they may have contributed to the space dimension).

template<typename ITV >

Parma_Polyhedra_Library::Box< ITV >::Box | ( | const Constraint_System & | cs,
|  | Recycle_Input | dummy |
| ) |  |  | `[inline]`

Builds a box recycling a system of constraints `cs`.

The box inherits the space dimension of `cs`.

Parameters:

  | cs | A system of constraints: constraints that are not interval constraints are ignored (even though they may have contributed to the space dimension).
  | dummy | A dummy tag to syntactically differentiate this one from the other constructors.

template<typename ITV >

Parma_Polyhedra_Library::Box< ITV >::Box | ( | const Generator_System & | gs | ) | `[inline, explicit]`

Builds a box from the system of generators `gs`.

Builds the smallest box containing the polyhedron defined by `gs`. The box inherits the space dimension of `gs`.

Exceptions:

  | std::invalid_argument | Thrown if the system of generators is not empty but has no points.

template<typename ITV >

Parma_Polyhedra_Library::Box< ITV >::Box | ( | const Generator_System & | gs,
|  | Recycle_Input | dummy |
| ) |  |  | `[inline]`

Builds a box recycling the system of generators `gs`.

Builds the smallest box containing the polyhedron defined by `gs`. The box inherits the space dimension of `gs`.

Parameters:

  | gs | The generator system describing the polyhedron to be approximated.
  | dummy | A dummy tag to syntactically differentiate this one from the other constructors.

Exceptions:

  | std::invalid_argument | Thrown if the system of generators is not empty but has no points.

template<typename ITV >

Parma_Polyhedra_Library::Box< ITV >::Box | ( | const Congruence_System & | cgs | ) | `[inline, explicit]`

Builds the smallest box containing the grid defined by a system of congruences `cgs`. The box inherits the space dimension of `cgs`.

Parameters:

  | cgs | A system of congruences: congruences that are not non-relational equality constraints are ignored (though they may have contributed to the space dimension).

template<typename ITV >

Parma_Polyhedra_Library::Box< ITV >::Box | ( | const Congruence_System & | cgs,
|  | Recycle_Input | dummy |
| ) |  |  | `[inline]`

Builds the smallest box containing the grid defined by a system of congruences `cgs`, recycling `cgs`. The box inherits the space dimension of `cgs`.

Parameters:

  | cgs | A system of congruences: congruences that are not non-relational equality constraints are ignored (though they will contribute to the space dimension).
  | dummy | A dummy tag to syntactically differentiate this one from the other constructors.

template<typename ITV >
template<typename T >

Parma_Polyhedra_Library::Box< ITV >::Box | ( | const BD_Shape< T > & | bds,
|  | Complexity_Class | complexity = `POLYNOMIAL_COMPLEXITY` |
| ) |  |  | `[inline, explicit]`

Builds a box containing the BDS `bds`.

Builds the smallest box containing `bds` using a polynomial algorithm. The `complexity` argument is ignored.

template<typename ITV >
template<typename T >

Parma_Polyhedra_Library::Box< ITV >::Box | ( | const Octagonal_Shape< T > & | oct,
|  | Complexity_Class | complexity = `POLYNOMIAL_COMPLEXITY` |
| ) |  |  | `[inline, explicit]`

Builds a box containing the octagonal shape `oct`.

Builds the smallest box containing `oct` using a polynomial algorithm. The `complexity` argument is ignored.

template<typename ITV >

Parma_Polyhedra_Library::Box< ITV >::Box | ( | const Polyhedron & | ph,
|  | Complexity_Class | complexity = `ANY_COMPLEXITY` |
| ) |  |  | `[inline, explicit]`

Builds a box containing the polyhedron `ph`.

Builds a box containing `ph` using algorithms whose complexity does not exceed the one specified by `complexity`. If `complexity` is `ANY_COMPLEXITY`, then the built box is the smallest one containing `ph`.

template<typename ITV >

Parma_Polyhedra_Library::Box< ITV >::Box | ( | const Grid & | ph,
|  | Complexity_Class | complexity = `POLYNOMIAL_COMPLEXITY` |
| ) |  |  | `[inline, explicit]`

Builds a box containing the grid `gr`.

Builds the smallest box containing `gr` using a polynomial algorithm. The `complexity` argument is ignored.

template<typename ITV >
template<typename D1 , typename D2 , typename R >

Parma_Polyhedra_Library::Box< ITV >::Box | ( | const Partially_Reduced_Product< D1, D2, R > & | dp,
|  | Complexity_Class | complexity = `ANY_COMPLEXITY` |
| ) |  |  | `[inline, explicit]`

Builds a box containing the partially reduced product `dp`.

Builds a box containing `ph` using algorithms whose complexity does not exceed the one specified by `complexity`.

## Member Function Documentation

template<typename ITV >

bool Parma_Polyhedra_Library::Box< ITV >::constrains | ( | Variable | var | ) | const`[inline]`

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

Exceptions:

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

template<typename ITV >

Poly_Con_Relation Parma_Polyhedra_Library::Box< ITV >::relation_with | ( | const Constraint & | c | ) | const`[inline]`

Returns the relations holding between `*this` and the constraint `c`.

Exceptions:

  | std::invalid_argument | Thrown if `*this` and constraint `c` are dimension-incompatible.

template<typename ITV >

Poly_Con_Relation Parma_Polyhedra_Library::Box< ITV >::relation_with | ( | const Congruence & | cg | ) | const`[inline]`

Returns the relations holding between `*this` and the congruence `cg`.

Exceptions:

  | std::invalid_argument | Thrown if `*this` and constraint `cg` are dimension-incompatible.

template<typename ITV >

Poly_Gen_Relation Parma_Polyhedra_Library::Box< ITV >::relation_with | ( | const Generator & | g | ) | const`[inline]`

Returns the relations holding between `*this` and the generator `g`.

Exceptions:

  | std::invalid_argument | Thrown if `*this` and generator `g` are dimension-incompatible.

template<typename ITV >

bool Parma_Polyhedra_Library::Box< ITV >::bounds_from_above | ( | const Linear_Expression & | expr | ) | const`[inline]`

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

Exceptions:

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

template<typename ITV >

bool Parma_Polyhedra_Library::Box< ITV >::bounds_from_below | ( | const Linear_Expression & | expr | ) | const`[inline]`

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

Exceptions:

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

template<typename ITV >

bool Parma_Polyhedra_Library::Box< ITV >::maximize | ( | const Linear_Expression & | expr,
|  | Coefficient & | sup_n,
|  | Coefficient & | sup_d,
|  | bool & | maximum |
| ) |  |  | const`[inline]`

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

Parameters:

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

Exceptions:

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

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

template<typename ITV >

bool Parma_Polyhedra_Library::Box< ITV >::maximize | ( | const Linear_Expression & | expr,
|  | Coefficient & | sup_n,
|  | Coefficient & | sup_d,
|  | bool & | maximum,
|  | Generator & | g |
| ) |  |  | const`[inline]`

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

Parameters:

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

Exceptions:

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

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

template<typename ITV >

bool Parma_Polyhedra_Library::Box< ITV >::minimize | ( | const Linear_Expression & | expr,
|  | Coefficient & | inf_n,
|  | Coefficient & | inf_d,
|  | bool & | minimum |
| ) |  |  | const`[inline]`

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

Parameters:

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

Exceptions:

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

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

template<typename ITV >

bool Parma_Polyhedra_Library::Box< ITV >::minimize | ( | const Linear_Expression & | expr,
|  | Coefficient & | inf_n,
|  | Coefficient & | inf_d,
|  | bool & | minimum,
|  | Generator & | g |
| ) |  |  | const`[inline]`

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

Parameters:

  | expr | The linear expression to be minimized subject to `*this`;
  | inf_n | The numerator of the infimum value;
  | inf_d | The denominator of the infimum value;
  | minimum | `true` if and only if the infimum is also the minimum value;
  | g | When minimization succeeds, will be assigned a point or closure point where `expr` reaches its infimum value.

Exceptions:

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

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

template<typename ITV >

bool Parma_Polyhedra_Library::Box< ITV >::contains | ( | const Box< ITV > & | y | ) | const`[inline]`

Returns `true` if and only if `*this` contains `y`.

Exceptions:

  | std::invalid_argument | Thrown if `x` and `y` are dimension-incompatible.

template<typename ITV >

bool Parma_Polyhedra_Library::Box< ITV >::strictly_contains | ( | const Box< ITV > & | y | ) | const`[inline]`

Returns `true` if and only if `*this` strictly contains `y`.

Exceptions:

  | std::invalid_argument | Thrown if `x` and `y` are dimension-incompatible.

template<typename ITV >

bool Parma_Polyhedra_Library::Box< ITV >::is_disjoint_from | ( | const Box< ITV > & | y | ) | const`[inline]`

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

Exceptions:

  | std::invalid_argument | Thrown if `x` and `y` are dimension-incompatible.

template<typename ITV >

void Parma_Polyhedra_Library::Box< ITV >::add_constraint | ( | const Constraint & | c | ) | `[inline]`

Adds a copy of constraint `c` to the system of constraints defining `*this`.

Parameters:

  | c | The constraint to be added.

Exceptions:

  | std::invalid_argument | Thrown if `*this` and constraint `c` are dimension-incompatible, or `c` is not optimally supported by the Box domain.

template<typename ITV >

void Parma_Polyhedra_Library::Box< ITV >::add_constraints | ( | const Constraint_System & | cs | ) | `[inline]`

Adds the constraints in `cs` to the system of constraints defining `*this`.

Parameters:

  | cs | The constraints to be added.

Exceptions:

  | std::invalid_argument | Thrown if `*this` and `cs` are dimension-incompatible, or `cs` contains a constraint which is not optimally supported by the box domain.

template<typename T >

void Parma_Polyhedra_Library::Box< T >::add_recycled_constraints | ( | Constraint_System & | cs | ) | `[inline]`

Adds the constraints in `cs` to the system of constraints defining `*this`.

Parameters:

  | cs | The constraints to be added. They may be recycled.

Exceptions:

  | std::invalid_argument | Thrown if `*this` and `cs` are dimension-incompatible, or `cs` contains a constraint which is not optimally supported by the box domain.

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

template<typename ITV >

void Parma_Polyhedra_Library::Box< ITV >::add_congruence | ( | const Congruence & | cg | ) | `[inline]`

Adds to `*this` a constraint equivalent to the congruence `cg`.

Parameters:

  | cg | The congruence to be added.

Exceptions:

  | std::invalid_argument | Thrown if `*this` and congruence `cg` are dimension-incompatible, or `cg` is not optimally supported by the box domain.

template<typename ITV >

void Parma_Polyhedra_Library::Box< ITV >::add_congruences | ( | const Congruence_System & | cgs | ) | `[inline]`

Adds to `*this` constraints equivalent to the congruences in `cgs`.

Parameters:

  | cgs | The congruences to be added.

Exceptions:

  | std::invalid_argument | Thrown if `*this` and `cgs` are dimension-incompatible, or `cgs` contains a congruence which is not optimally supported by the box domain.

template<typename T >

void Parma_Polyhedra_Library::Box< T >::add_recycled_congruences | ( | Congruence_System & | cgs | ) | `[inline]`

Adds to `*this` constraints equivalent to the congruences in `cgs`.

Parameters:

  | cgs | The congruence system to be added to `*this`. The congruences in `cgs` may be recycled.

Exceptions:

  | std::invalid_argument | Thrown if `*this` and `cgs` are dimension-incompatible, or `cgs` contains a congruence which is not optimally supported by the box domain.

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

template<typename ITV >

void Parma_Polyhedra_Library::Box< ITV >::refine_with_constraint | ( | const Constraint & | c | ) | `[inline]`

Use the constraint `c` to refine `*this`.

Parameters:

  | c | The constraint to be used for refinement.

Exceptions:

  | std::invalid_argument | Thrown if `*this` and `c` are dimension-incompatible.

template<typename ITV >

void Parma_Polyhedra_Library::Box< ITV >::refine_with_constraints | ( | const Constraint_System & | cs | ) | `[inline]`

Use the constraints in `cs` to refine `*this`.

Parameters:

  | cs | The constraints to be used for refinement.

Exceptions:

  | std::invalid_argument | Thrown if `*this` and `cs` are dimension-incompatible.

template<typename ITV >

void Parma_Polyhedra_Library::Box< ITV >::refine_with_congruence | ( | const Congruence & | cg | ) | `[inline]`

Use the congruence `cg` to refine `*this`.

Parameters:

  | cg | The congruence to be used for refinement.

Exceptions:

  | std::invalid_argument | Thrown if `*this` and `cg` are dimension-incompatible.

template<typename ITV >

void Parma_Polyhedra_Library::Box< ITV >::refine_with_congruences | ( | const Congruence_System & | cgs | ) | `[inline]`

Use the congruences in `cgs` to refine `*this`.

Parameters:

  | cgs | The congruences to be used for refinement.

Exceptions:

  | std::invalid_argument | Thrown if `*this` and `cgs` are dimension-incompatible.

template<typename ITV >

void Parma_Polyhedra_Library::Box< ITV >::propagate_constraint | ( | const Constraint & | c | ) | `[inline]`

Use the constraint `c` for constraint propagation on `*this`.

Parameters:

  | c | The constraint to be used for constraint propagation.

Exceptions:

  | std::invalid_argument | Thrown if `*this` and `c` are dimension-incompatible.

template<typename ITV >

void Parma_Polyhedra_Library::Box< ITV >::propagate_constraints | ( | const Constraint_System & | cs | ) | `[inline]`

Use the constraints in `cs` for constraint propagagion on `*this`.

Parameters:

  | cs | The constraints to be used for constraint propagation.

Exceptions:

  | std::invalid_argument | Thrown if `*this` and `cs` are dimension-incompatible.

template<typename ITV >

void Parma_Polyhedra_Library::Box< ITV >::unconstrain | ( | Variable | var | ) | `[inline]`

Computes the cylindrification of `*this` with respect to space dimension `var`, assigning the result to `*this`.

Parameters:

  | var | The space dimension that will be unconstrained.

Exceptions:

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

template<typename ITV >

void Parma_Polyhedra_Library::Box< ITV >::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`.

Parameters:

  | to_be_unconstrained | The set of space dimension that will be unconstrained.

Exceptions:

  | std::invalid_argument | Thrown if `*this` is dimension-incompatible with one of the Variable objects contained in `to_be_removed`.

template<typename ITV >

void Parma_Polyhedra_Library::Box< ITV >::intersection_assign | ( | const Box< ITV > & | y | ) | `[inline]`

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

Exceptions:

  | std::invalid_argument | Thrown if `*this` and `y` are dimension-incompatible.

template<typename ITV >

void Parma_Polyhedra_Library::Box< ITV >::upper_bound_assign | ( | const Box< ITV > & | y | ) | `[inline]`

Assigns to `*this` the smallest box containing the union of `*this` and `y`.

Exceptions:

  | std::invalid_argument | Thrown if `*this` and `y` are dimension-incompatible.

template<typename ITV >

bool Parma_Polyhedra_Library::Box< ITV >::upper_bound_assign_if_exact | ( | const Box< ITV > & | y | ) | `[inline]`

If the upper bound of `*this` and `y` is exact, it is assigned to `*this` and `true` is returned, otherwise `false` is returned.

Exceptions:

  | std::invalid_argument | Thrown if `*this` and `y` are dimension-incompatible.

template<typename ITV >

void Parma_Polyhedra_Library::Box< ITV >::difference_assign | ( | const Box< ITV > & | y | ) | `[inline]`

Assigns to `*this` the difference of `*this` and `y`.

Exceptions:

  | std::invalid_argument | Thrown if `*this` and `y` are dimension-incompatible.

template<typename ITV >

bool Parma_Polyhedra_Library::Box< ITV >::simplify_using_context_assign | ( | const Box< ITV > & | y | ) | `[inline]`

Assigns to `*this` a meet-preserving simplification of `*this` with respect to `y`. If `false` is returned, then the intersection is empty.

Exceptions:

  | std::invalid_argument | Thrown if `*this` and `y` are dimension-incompatible.

template<typename ITV >

void Parma_Polyhedra_Library::Box< ITV >::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`.

Parameters:

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

Exceptions:

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

template<typename ITV >

void Parma_Polyhedra_Library::Box< ITV >::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`.

Parameters:

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

Exceptions:

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

template<typename ITV >

void Parma_Polyhedra_Library::Box< ITV >::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`.

Parameters:

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

Exceptions:

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

template<typename ITV >

void Parma_Polyhedra_Library::Box< ITV >::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`.

Parameters:

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

Exceptions:

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

template<typename ITV >

void Parma_Polyhedra_Library::Box< ITV >::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`.

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

template<typename ITV >

void Parma_Polyhedra_Library::Box< ITV >::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`.

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

template<typename ITV >

void Parma_Polyhedra_Library::Box< ITV >::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 .

Parameters:

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

Exceptions:

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

template<typename ITV >

void Parma_Polyhedra_Library::Box< ITV >::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 .

Parameters:

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

Exceptions:

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

template<typename ITV >

void Parma_Polyhedra_Library::Box< ITV >::time_elapse_assign | ( | const Box< ITV > & | y | ) | `[inline]`

Assigns to `*this` the result of computing the time-elapse between `*this` and `y`.

Exceptions:

  | std::invalid_argument | Thrown if `*this` and `y` are dimension-incompatible.

template<typename ITV >

void Parma_Polyhedra_Library::Box< ITV >::CC76_widening_assign | ( | const Box< ITV > & | y,
|  | unsigned * | tp = `0` |
| ) |  |  | `[inline]`

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

Parameters:

  | y | A box 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 dimension-incompatible.

template<typename ITV >
template<typename Iterator >

void Parma_Polyhedra_Library::Box< ITV >::CC76_widening_assign | ( | const Box< ITV > & | y,
|  | Iterator | first,
|  | Iterator | last |
| ) |  |  | `[inline]`

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

Parameters:

  | y | A box that must be contained in `*this`.
  | first | An iterator that points to the first stop-point.
  | last | An iterator that points one past the last stop-point.

Exceptions:

  | std::invalid_argument | Thrown if `*this` and `y` are dimension-incompatible.

template<typename ITV >

void Parma_Polyhedra_Library::Box< ITV >::limited_CC76_extrapolation_assign | ( | const Box< ITV > & | y,
|  | const Constraint_System & | cs,
|  | unsigned * | tp = `0` |
| ) |  |  | `[inline]`

Improves the result of the CC76-extrapolation computation by also enforcing those constraints in `cs` that are satisfied by all the points of `*this`.

Parameters:

  | y | A box that must be contained in `*this`.
  | cs | The system of constraints used to improve the widened box.
  | 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 dimension-incompatible or if `cs` contains a strict inequality.

template<typename ITV >

void Parma_Polyhedra_Library::Box< ITV >::CC76_narrowing_assign | ( | const Box< ITV > & | y | ) | `[inline]`

Assigns to `*this` the result of restoring in `y` the constraints of `*this` that were lost by CC76-extrapolation applications.

Parameters:

  | y | A Box that must contain `*this`.

Exceptions:

  | std::invalid_argument | Thrown if `*this` and `y` are dimension-incompatible.

Note:
  As was the case for widening operators, the argument `y` is meant to denote the value computed in the previous iteration step, whereas `*this` denotes the value computed in the current iteration step (in the decreasing iteration sequence). Hence, the call `x.CC76_narrowing_assign(y)` will assign to `x` the result of the computation .

template<typename ITV >

void Parma_Polyhedra_Library::Box< ITV >::add_space_dimensions_and_embed | ( | dimension_type | m | ) | `[inline]`

Adds `m` new dimensions and embeds the old box into the new space.

Parameters:

  | m | The number of dimensions to add.

The new dimensions will be those having the highest indexes in the new box, which is defined by a system of interval constraints in which the variables running through the new dimensions are unconstrained. For instance, when starting from the box and adding a third dimension, the result will be the box

template<typename ITV >

void Parma_Polyhedra_Library::Box< ITV >::add_space_dimensions_and_project | ( | dimension_type | m | ) | `[inline]`

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

Parameters:

  | m | The number of dimensions to add.

The new dimensions will be those having the highest indexes in the new box, which is defined by a system of bounded differences in which the variables running through the new dimensions are all constrained to be equal to 0. For instance, when starting from the box and adding a third dimension, the result will be the box

template<typename ITV >

void Parma_Polyhedra_Library::Box< ITV >::concatenate_assign | ( | const Box< ITV > & | y | ) | `[inline]`

Seeing a box as a set of tuples (its points), assigns to `*this` all the tuples that can be obtained by concatenating, in the order given, a tuple of `*this` with a tuple of `y`.

Let and be the boxes corresponding, on entry, to `*this` and `y`, respectively. Upon successful completion, `*this` will represent the box such that

Another way of seeing it is as follows: first increases the space dimension of `*this` by adding `y.space_dimension()` new dimensions; then adds to the system of constraints of `*this` a renamed-apart version of the constraints of `y`.

template<typename ITV >

void Parma_Polyhedra_Library::Box< ITV >::remove_space_dimensions | ( | const Variables_Set & | to_be_removed | ) | `[inline]`

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

template<typename ITV >

void Parma_Polyhedra_Library::Box< ITV >::remove_higher_space_dimensions | ( | dimension_type | new_dimension | ) | `[inline]`

Removes the higher dimensions so that the resulting space will have dimension `new_dimension`.

Exceptions:

  | std::invalid_argument | Thrown if `new_dimension` is greater than the space dimension of `*this`.

template<typename ITV >
template<typename Partial_Function >

void Parma_Polyhedra_Library::Box< ITV >::map_space_dimensions | ( | const Partial_Function & | pfunc | ) | `[inline]`

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 Partial_Function must provide the following methods.

          bool has_empty_codomain() const

returns `true` if and only if the represented partial function has an empty co-domain (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 co-domain of the partial function.

          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.

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

template<typename ITV >

void Parma_Polyhedra_Library::Box< ITV >::expand_space_dimension | ( | Variable | var,
|  | dimension_type | m |
| ) |  |  | `[inline]`

Creates `m` copies of the space dimension corresponding to `var`.

Parameters:

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

Exceptions:

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

If `*this` has space dimension , with , and `var` has space dimension , then the -th space dimension is expanded to `m` new space dimensions , , , .

template<typename ITV >

void Parma_Polyhedra_Library::Box< ITV >::fold_space_dimensions | ( | const Variables_Set & | to_be_folded,
|  | Variable | var |
| ) |  |  | `[inline]`

Folds the space dimensions in `to_be_folded` into `var`.

Parameters:

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

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

template<typename ITV >

const ITV & Parma_Polyhedra_Library::Box< ITV >::get_interval | ( | Variable | var | ) | const`[inline]`

Returns a reference the interval that bounds `var`.

Exceptions:

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

template<typename ITV >

void Parma_Polyhedra_Library::Box< ITV >::set_interval | ( | Variable | var,
|  | const ITV & | i |
| ) |  |  | `[inline]`

Sets to `i` the interval that bounds `var`.

Exceptions:

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

template<typename ITV >

bool Parma_Polyhedra_Library::Box< ITV >::get_lower_bound | ( | dimension_type | k,
|  | bool & | closed,
|  | Coefficient & | n,
|  | Coefficient & | d |
| ) |  |  | const`[inline]`

If the `k`-th space dimension is unbounded below, returns `false`. Otherwise returns `true` and set `closed`, `n` and `d` accordingly.

Let the interval corresponding to the `k`-th space 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.

An undefined behavior is obtained if `k` is greater than or equal to the space dimension of `*this`.

template<typename ITV >

bool Parma_Polyhedra_Library::Box< ITV >::get_upper_bound | ( | dimension_type | k,
|  | bool & | closed,
|  | Coefficient & | n,
|  | Coefficient & | d |
| ) |  |  | const`[inline]`

If the `k`-th space dimension is unbounded above, returns `false`. Otherwise returns `true` and set `closed`, `n` and `d` accordingly.

Let the interval corresponding to the `k`-th space 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 .

An undefined behavior is obtained if `k` is greater than or equal to the space dimension of `*this`.

## Friends And Related Function Documentation

template<typename ITV >

bool operator== | ( | const Box< ITV > & | x,
|  | const Box< ITV > & | y |
| ) |  |  | `[friend]`

Returns `true` if and only if `x` and `y` are the same box.

Note that `x` and `y` may be dimension-incompatible boxes: in this case, the value `false` is returned.

template<typename ITV >

bool operator!= | ( | const Box< ITV > & | x,
|  | const Box< ITV > & | y |
| ) |  |  | `[related]`

Returns `true` if and only if `x` and `y` aren't the same box.

Note that `x` and `y` may be dimension-incompatible boxes: in this case, the value `true` is returned.

template<typename ITV >

std::ostream & operator<< | ( | std::ostream & | s,
|  | const Box< ITV > & | box |
| ) |  |  | `[related]`

Output operator.

template<typename To , typename ITV >

bool rectilinear_distance_assign | ( | Checked_Number< To, Extended_Number_Policy > & | r,
|  | const Box< ITV > & | x,
|  | const Box< ITV > & | y,
|  | Rounding_Dir | dir |
| ) |  |  | `[related]`

Computes the rectilinear (or Manhattan) distance between `x` and `y`.

If the rectilinear distance between `x` and `y` is defined, stores an approximation of it into `r` and returns `true`; returns `false` otherwise.

The direction of the approximation is specified by `dir`.

All computations are performed using variables of type Checked_Number<To, Extended_Number_Policy>.

If the rectilinear distance between `x` and `y` is defined, stores an approximation of it into `r` and returns `true`; returns `false` otherwise.

The direction of the approximation is specified by `dir`.

All computations are performed using variables of type Checked_Number<Temp, Extended_Number_Policy>.

template<typename Temp , typename To , typename ITV >

bool rectilinear_distance_assign | ( | Checked_Number< To, Extended_Number_Policy > & | r,
|  | const Box< ITV > & | x,
|  | const Box< ITV > & | y,
|  | Rounding_Dir | dir,
|  | Temp & | tmp0,
|  | Temp & | tmp1,
|  | Temp & | tmp2 |
| ) |  |  | `[related]`

Computes the rectilinear (or Manhattan) distance between `x` and `y`.

If the rectilinear distance between `x` and `y` is defined, stores an approximation of it into `r` and returns `true`; returns `false` otherwise.

The direction of the approximation is specified by `dir`.

All computations are performed using the temporary variables `tmp0`, `tmp1` and `tmp2`.

template<typename To , typename ITV >

bool euclidean_distance_assign | ( | Checked_Number< To, Extended_Number_Policy > & | r,
|  | const Box< ITV > & | x,
|  | const Box< ITV > & | y,
|  | Rounding_Dir | dir |
| ) |  |  | `[related]`

Computes the euclidean distance between `x` and `y`.

If the euclidean distance between `x` and `y` is defined, stores an approximation of it into `r` and returns `true`; returns `false` otherwise.

The direction of the approximation is specified by `dir`.

All computations are performed using variables of type Checked_Number<To, Extended_Number_Policy>.

If the euclidean distance between `x` and `y` is defined, stores an approximation of it into `r` and returns `true`; returns `false` otherwise.

The direction of the approximation is specified by `dir`.

All computations are performed using variables of type Checked_Number<Temp, Extended_Number_Policy>.

template<typename Temp , typename To , typename ITV >

bool euclidean_distance_assign | ( | Checked_Number< To, Extended_Number_Policy > & | r,
|  | const Box< ITV > & | x,
|  | const Box< ITV > & | y,
|  | Rounding_Dir | dir,
|  | Temp & | tmp0,
|  | Temp & | tmp1,
|  | Temp & | tmp2 |
| ) |  |  | `[related]`

Computes the euclidean distance between `x` and `y`.

If the euclidean distance between `x` and `y` is defined, stores an approximation of it into `r` and returns `true`; returns `false` otherwise.

The direction of the approximation is specified by `dir`.

All computations are performed using the temporary variables `tmp0`, `tmp1` and `tmp2`.

template<typename To , typename ITV >

bool l_infinity_distance_assign | ( | Checked_Number< To, Extended_Number_Policy > & | r,
|  | const Box< ITV > & | x,
|  | const Box< ITV > & | y,
|  | Rounding_Dir | dir |
| ) |  |  | `[related]`

Computes the distance between `x` and `y`.

If the distance between `x` and `y` is defined, stores an approximation of it into `r` and returns `true`; returns `false` otherwise.

The direction of the approximation is specified by `dir`.

All computations are performed using variables of type Checked_Number<To, Extended_Number_Policy>.

If the distance between `x` and `y` is defined, stores an approximation of it into `r` and returns `true`; returns `false` otherwise.

The direction of the approximation is specified by `dir`.

All computations are performed using variables of type Checked_Number<Temp, Extended_Number_Policy>.

template<typename Temp , typename To , typename ITV >

bool l_infinity_distance_assign | ( | Checked_Number< To, Extended_Number_Policy > & | r,
|  | const Box< ITV > & | x,
|  | const Box< ITV > & | y,
|  | Rounding_Dir | dir,
|  | Temp & | tmp0,
|  | Temp & | tmp1,
|  | Temp & | tmp2 |
| ) |  |  | `[related]`

Computes the distance between `x` and `y`.

If the distance between `x` and `y` is defined, stores an approximation of it into `r` and returns `true`; returns `false` otherwise.

The direction of the approximation is specified by `dir`.

All computations are performed using the temporary variables `tmp0`, `tmp1` and `tmp2`.

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

- ppl.hh