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 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 $0$ , 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)

Use the constraint c to refine *this. FIXME: this is not true.

void add_constraints (const Constraint_System &cs)

Use the constraints in cs to refine *this. FIXME: this is not true.

void add_recycled_constraints (Constraint_System &cs)

Use the constraints in cs to refine *this. FIXME: this is not true.

void add_congruence (const Congruence &cg)

Use the congruence cg to refine *this.

void add_congruences (const Congruence_System &cgs)

Use the congruences in cgs to refine *this.

void add_recycled_congruences (Congruence_System &cgs)

Use the congruences in cgs to refine *this.

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 $\mathrm{var}' \relsym \frac{\mathrm{expr}}{\mathrm{denominator}}$ , where $\mathord{\relsym}$ 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 $\mathrm{var}' \relsym \frac{\mathrm{expr}}{\mathrm{denominator}}$ , where $\mathord{\relsym}$ 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 $\mathrm{lhs}' \relsym \mathrm{rhs}$ , where $\mathord{\relsym}$ 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 $\mathrm{lhs}' \relsym \mathrm{rhs}$ , where $\mathord{\relsym}$ 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 $\frac{\mathrm{lb\_expr}}{\mathrm{denominator}} \leq \mathrm{var}' \leq \frac{\mathrm{ub\_expr}}{\mathrm{denominator}}$ .

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

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

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 $L_\infty$ 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 $L_\infty$ 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 Cartesian product of $n$ not necessarily closed and possibly unbounded intervals represented by objects of class ITV, where $n$ is the space dimension of the box.

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]

Use the constraint c to refine *this. FIXME: this is not true.

Parameters:

c

The constraint to be added. If it is not an interval constraint, it will be simply ignored.

Exceptions:

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

template<typename ITV >

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

Use the constraints in cs to refine *this. FIXME: this is not true.

Parameters:

cs

The constraints to be added. Constraints that are not interval constraints will be simply ignored.

Exceptions:

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

template<typename T >

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

Use the constraints in cs to refine *this. FIXME: this is not true.

Parameters:

cs The constraints to be added. Constraints that are not interval constraints will be simply ignored. The constraints in cs may be recycled.

Exceptions:

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

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]

Use the congruence cg to refine *this.

Parameters:

cg

The congruence to be used. If it is not a non-relational equality, the box is not changed.

Exceptions:

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

template<typename ITV >

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

Use the congruences in cgs to refine *this.

Parameters:

cgs

The congruences to be used. Congruences that are not non-relational equalities are not added although their space dimension is checked for compatibility.

Exceptions:

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

template<typename T >

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

Use the congruences in cgs to refine *this.

Parameters:

cgs The congruences to be used. Congruences that are not non-relational equalities are not added although their space dimension is checked for compatibility. The congruences in cgs may be recycled.

Exceptions:

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

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 topology-incompatible or 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 $\mathrm{var}' \relsym \frac{\mathrm{expr}}{\mathrm{denominator}}$ , where $\mathord{\relsym}$ is the relation symbol encoded by relsym.

Parameters:

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

Exceptions:

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

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 $\mathrm{var}' \relsym \frac{\mathrm{expr}}{\mathrm{denominator}}$ , where $\mathord{\relsym}$ is the relation symbol encoded by relsym.

Parameters:

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

Exceptions:

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

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 $\mathrm{lhs}' \relsym \mathrm{rhs}$ , where $\mathord{\relsym}$ is the relation symbol encoded by relsym.

Parameters:

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

Exceptions:

std::invalid_argument Thrown if *this is dimension-incompatible with lhs or rhs.

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 $\mathrm{lhs}' \relsym \mathrm{rhs}$ , where $\mathord{\relsym}$ is the relation symbol encoded by relsym.

Parameters:

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

Exceptions:

std::invalid_argument Thrown if *this is dimension-incompatible with lhs or rhs.

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 $\frac{\mathrm{lb\_expr}}{\mathrm{denominator}} \leq \mathrm{var}' \leq \frac{\mathrm{ub\_expr}}{\mathrm{denominator}}$ .

Parameters:

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

Exceptions:

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

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 $\frac{\mathrm{lb\_expr}}{\mathrm{denominator}} \leq \mathrm{var}' \leq \frac{\mathrm{ub\_expr}}{\mathrm{denominator}}$ .

Parameters:

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

Exceptions:

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

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 $\mathtt{y} \Delta \mathtt{x}$ .

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 $\cB \sseq \Rset^2$ and adding a third dimension, the result will be the box

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

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 $\cB \sseq \Rset^2$ and adding a third dimension, the result will be the box

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

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 $B \sseq \Rset^n$ and $D \sseq \Rset^m$ be the boxes corresponding, on entry, to *this and y, respectively. Upon successful completion, *this will represent the box $R \sseq \Rset^{n+m}$ such that

$R \defeq \Bigl\{\, (x_1, \ldots, x_n, y_1, \ldots, y_m)^\transpose \Bigm| (x_1, \ldots, x_n)^\transpose \in B, (y_1, \ldots, y_m)^\transpose \in D \,\Bigl\}.$

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 $k$

be the value of i. If $f$

is defined in $k$

, then

is assigned to j and true is returned. If $f$

is undefined in $k$

, 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 $n$

, with

, and var has space dimension $k \leq n$ , then the $k$

-th space dimension is expanded to m new space dimensions $n$

,

, $\dots$ , $n+m-1$

.

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 $n$

, with

, var has space dimension $k \leq n$ , to_be_folded is a set of variables whose maximum space dimension is also less than or equal to $n$

, 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 $k$

-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 $I$ the interval corresponding to the k-th space dimension. If $I$ 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 $I$ is closed and is set to false otherwise; n and d are assigned the integers $n$ and $d$ such that the canonical fraction $n/d$ corresponds to the greatest lower bound of $I$ . The fraction $n/d$ is in canonical form if and only if $n$ and $d$ have no common factors and $d$ is positive, $0/1$ 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 $I$ the interval corresponding to the k-th space dimension. If $I$ 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 $I$ is closed and is set to false otherwise; n and d are assigned the integers $n$ and $d$ such that the canonical fraction $n/d$ corresponds to the least upper bound of $I$ .

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.