PPL 1.0

- Main Page
- Related Pages
- Modules
- Namespaces
- Classes

- Class List
- Class Hierarchy
- Class Members

Public Member Functions
Parma_Polyhedra_Library::NNC_Polyhedron Class Reference
C++ Language Interface

A not necessarily closed convex polyhedron. More...

`#include <ppl.hh>`

Inheritance diagram for Parma_Polyhedra_Library::NNC_Polyhedron:
[legend]

List of all members.

## Public Member Functions
| NNC_Polyhedron (dimension_type num_dimensions=0, Degenerate_Element kind=UNIVERSE)
| Builds either the universe or the empty NNC polyhedron.
| NNC_Polyhedron (const Constraint_System &cs)
| Builds an NNC polyhedron from a system of constraints.
| NNC_Polyhedron (Constraint_System &cs, Recycle_Input dummy)
| Builds an NNC polyhedron recycling a system of constraints.
| NNC_Polyhedron (const Generator_System &gs)
| Builds an NNC polyhedron from a system of generators.
| NNC_Polyhedron (Generator_System &gs, Recycle_Input dummy)
| Builds an NNC polyhedron recycling a system of generators.
| NNC_Polyhedron (const Congruence_System &cgs)
| Builds an NNC polyhedron from a system of congruences.
| NNC_Polyhedron (Congruence_System &cgs, Recycle_Input dummy)
| Builds an NNC polyhedron recycling a system of congruences.
| NNC_Polyhedron (const C_Polyhedron &y, Complexity_Class complexity=ANY_COMPLEXITY)
| Builds an NNC polyhedron from the C polyhedron `y`.
template<typename Interval >
| NNC_Polyhedron (const Box< Interval > &box, Complexity_Class complexity=ANY_COMPLEXITY)
| Builds an NNC polyhedron out of a box.
| NNC_Polyhedron (const Grid &grid, Complexity_Class complexity=ANY_COMPLEXITY)
| Builds an NNC polyhedron out of a grid.
template<typename U >
| NNC_Polyhedron (const BD_Shape< U > &bd, Complexity_Class complexity=ANY_COMPLEXITY)
| Builds a NNC polyhedron out of a BD shape.
template<typename U >
| NNC_Polyhedron (const Octagonal_Shape< U > &os, Complexity_Class complexity=ANY_COMPLEXITY)
| Builds a NNC polyhedron out of an octagonal shape.
| NNC_Polyhedron (const NNC_Polyhedron &y, Complexity_Class complexity=ANY_COMPLEXITY)
| Ordinary copy constructor.
NNC_Polyhedron & | operator= (const NNC_Polyhedron &y)
| The assignment operator. (`*this` and `y` can be dimension-incompatible.)
NNC_Polyhedron & | operator= (const C_Polyhedron &y)
| Assigns to `*this` the C polyhedron `y`.
| ~NNC_Polyhedron ()
| Destructor.
bool | poly_hull_assign_if_exact (const NNC_Polyhedron &y)
| If the poly-hull of `*this` and `y` is exact it is assigned to `*this` and `true` is returned, otherwise `false` is returned.
bool | upper_bound_assign_if_exact (const NNC_Polyhedron &y)
| Same as poly_hull_assign_if_exact(y).
Public Member Functions inherited from Parma_Polyhedra_Library::Polyhedron
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`.
const Constraint_System & | constraints () const
| Returns the system of constraints.
const Constraint_System & | minimized_constraints () const
| Returns the system of constraints, with no redundant constraint.
const Generator_System & | generators () const
| Returns the system of generators.
const Generator_System & | minimized_generators () const
| Returns the system of generators, with no redundant generator.
Congruence_System | congruences () const
| Returns a system of (equality) congruences satisfied by `*this`.
Congruence_System | minimized_congruences () const
| Returns a system of (equality) congruences satisfied by `*this`, with no redundant congruences and having the same affine dimension as `*this`.
Poly_Con_Relation | relation_with (const Constraint &c) const
| Returns the relations holding between the polyhedron `*this` and the constraint `c`.
Poly_Gen_Relation | relation_with (const Generator &g) const
| Returns the relations holding between the polyhedron `*this` and the generator `g`.
Poly_Con_Relation | relation_with (const Congruence &cg) const
| Returns the relations holding between the polyhedron `*this` and the congruence `c`.
bool | is_empty () const
| Returns `true` if and only if `*this` is an empty polyhedron.
bool | is_universe () const
| Returns `true` if and only if `*this` is a universe polyhedron.
bool | is_topologically_closed () const
| Returns `true` if and only if `*this` is a topologically closed subset of the vector space.
bool | is_disjoint_from (const Polyhedron &y) const
| Returns `true` if and only if `*this` and `y` are disjoint.
bool | is_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 polyhedron.
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`.
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 | frequency (const Linear_Expression &expr, Coefficient &freq_n, Coefficient &freq_d, Coefficient &val_n, Coefficient &val_d) const
| Returns `true` if and only if there exist a unique value `val` such that `*this` saturates the equality `expr = val`.
bool | contains (const Polyhedron &y) const
| Returns `true` if and only if `*this` contains `y`.
bool | strictly_contains (const Polyhedron &y) const
| Returns `true` if and only if `*this` strictly contains `y`.
bool | OK (bool check_not_empty=false) const
| Checks if all the invariants are satisfied.
void | add_constraint (const Constraint &c)
| Adds a copy of constraint `c` to the system of constraints of `*this` (without minimizing the result).
void | add_generator (const Generator &g)
| Adds a copy of generator `g` to the system of generators of `*this` (without minimizing the result).
void | add_congruence (const Congruence &cg)
| Adds a copy of congruence `cg` to `*this`, if `cg` can be exactly represented by a polyhedron.
void | add_constraints (const Constraint_System &cs)
| Adds a copy of the constraints in `cs` to the system of constraints of `*this` (without minimizing the result).
void | add_recycled_constraints (Constraint_System &cs)
| Adds the constraints in `cs` to the system of constraints of `*this` (without minimizing the result).
void | add_generators (const Generator_System &gs)
| Adds a copy of the generators in `gs` to the system of generators of `*this` (without minimizing the result).
void | add_recycled_generators (Generator_System &gs)
| Adds the generators in `gs` to the system of generators of `*this` (without minimizing the result).
void | add_congruences (const Congruence_System &cgs)
| Adds a copy of the congruences in `cgs` to `*this`, if all the congruences can be exactly represented by a polyhedron.
void | add_recycled_congruences (Congruence_System &cgs)
| Adds the congruences in `cgs` to `*this`, if all the congruences can be exactly represented by a polyhedron.
void | refine_with_constraint (const Constraint &c)
| Uses a copy of constraint `c` to refine `*this`.
void | refine_with_congruence (const Congruence &cg)
| Uses a copy of congruence `cg` to refine `*this`.
void | refine_with_constraints (const Constraint_System &cs)
| Uses a copy of the constraints in `cs` to refine `*this`.
void | refine_with_congruences (const Congruence_System &cgs)
| Uses a copy of the congruences in `cgs` to refine `*this`.
template<typename FP_Format , typename Interval_Info >
void | refine_with_linear_form_inequality (const Linear_Form< Interval< FP_Format, Interval_Info > > &left, const Linear_Form< Interval< FP_Format, Interval_Info > > &right, bool is_strict=false)
| Refines `*this` with the constraint expressed by `left` `right` if `is_strict` is set, with the constraint `left` `right` otherwise.
template<typename FP_Format , typename Interval_Info >
void | generalized_refine_with_linear_form_inequality (const Linear_Form< Interval< FP_Format, Interval_Info > > &left, const Linear_Form< Interval< FP_Format, Interval_Info > > &right, Relation_Symbol relsym)
| Refines `*this` with the constraint expressed by `left` `right`, where is the relation symbol specified by `relsym`..
template<typename FP_Format , typename Interval_Info >
void | refine_fp_interval_abstract_store (Box< Interval< FP_Format, Interval_Info > > &store) const
| Refines `store` with the constraints defining `*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 &vars)
| Computes the cylindrification of `*this` with respect to the set of space dimensions `vars`, assigning the result to `*this`.
void | intersection_assign (const Polyhedron &y)
| Assigns to `*this` the intersection of `*this` and `y`.
void | poly_hull_assign (const Polyhedron &y)
| Assigns to `*this` the poly-hull of `*this` and `y`.
void | upper_bound_assign (const Polyhedron &y)
| Same as poly_hull_assign(y).
void | poly_difference_assign (const Polyhedron &y)
| Assigns to `*this` the poly-difference of `*this` and `y`.
void | difference_assign (const Polyhedron &y)
| Same as poly_difference_assign(y).
bool | simplify_using_context_assign (const Polyhedron &y)
| Assigns to `*this` a meet-preserving simplification of `*this` with respect to `y`. If `false` is returned, then the intersection is empty.
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`.
template<typename FP_Format , typename Interval_Info >
void | affine_form_image (Variable var, const Linear_Form< Interval< FP_Format, Interval_Info > > &lf)
void | affine_preimage (Variable var, const Linear_Expression &expr, Coefficient_traits::const_reference denominator=Coefficient_one())
| Assigns to `*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 Polyhedron &y)
| Assigns to `*this` the result of computing the time-elapse between `*this` and `y`.
void | wrap_assign (const Variables_Set &vars, Bounded_Integer_Type_Width w, Bounded_Integer_Type_Representation r, Bounded_Integer_Type_Overflow o, const Constraint_System *cs_p=0, unsigned complexity_threshold=16, bool wrap_individually=true)
| Wraps the specified dimensions of the vector space.
void | drop_some_non_integer_points (Complexity_Class complexity=ANY_COMPLEXITY)
| Possibly tightens `*this` by dropping some points with non-integer coordinates.
void | drop_some_non_integer_points (const Variables_Set &vars, Complexity_Class complexity=ANY_COMPLEXITY)
| Possibly tightens `*this` by dropping some points with non-integer coordinates for the space dimensions corresponding to `vars`.
void | topological_closure_assign ()
| Assigns to `*this` its topological closure.
void | BHRZ03_widening_assign (const Polyhedron &y, unsigned *tp=0)
| Assigns to `*this` the result of computing the BHRZ03-widening between `*this` and `y`.
void | limited_BHRZ03_extrapolation_assign (const Polyhedron &y, const Constraint_System &cs, unsigned *tp=0)
| Assigns to `*this` the result of computing the limited extrapolation between `*this` and `y` using the BHRZ03-widening operator.
void | bounded_BHRZ03_extrapolation_assign (const Polyhedron &y, const Constraint_System &cs, unsigned *tp=0)
| Assigns to `*this` the result of computing the bounded extrapolation between `*this` and `y` using the BHRZ03-widening operator.
void | H79_widening_assign (const Polyhedron &y, unsigned *tp=0)
| Assigns to `*this` the result of computing the H79_widening between `*this` and `y`.
void | widening_assign (const Polyhedron &y, unsigned *tp=0)
| Same as H79_widening_assign(y, tp).
void | limited_H79_extrapolation_assign (const Polyhedron &y, const Constraint_System &cs, unsigned *tp=0)
| Assigns to `*this` the result of computing the limited extrapolation between `*this` and `y` using the H79-widening operator.
void | bounded_H79_extrapolation_assign (const Polyhedron &y, const Constraint_System &cs, unsigned *tp=0)
| Assigns to `*this` the result of computing the bounded extrapolation between `*this` and `y` using the H79-widening operator.
void | add_space_dimensions_and_embed (dimension_type m)
| Adds `m` new space dimensions and embeds the old polyhedron in the new vector space.
void | add_space_dimensions_and_project (dimension_type m)
| Adds `m` new space dimensions to the polyhedron and does not embed it in the new vector space.
void | concatenate_assign (const Polyhedron &y)
| Assigns to `*this` the concatenation of `*this` and `y`, taken in this order.
void | remove_space_dimensions (const Variables_Set &vars)
| Removes all the specified dimensions from the vector space.
void | remove_higher_space_dimensions (dimension_type new_dimension)
| Removes the higher dimensions of the vector space so that the resulting space will have dimension `new_dimension`.
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 &vars, Variable dest)
| Folds the space dimensions in `vars` into `dest`.
| ~Polyhedron ()
| Destructor.
void | m_swap (Polyhedron &y)
| Swaps `*this` with polyhedron `y`. (`*this` and `y` can be dimension-incompatible.)
void | ascii_dump () const
| Writes to `std::cerr` an ASCII representation of `*this`.
void | ascii_dump (std::ostream &s) const
| Writes to `s` an ASCII representation of `*this`.
void | print () const
| Prints `*this` to `std::cerr` using `operator<<`.
bool | ascii_load (std::istream &s)
| Loads from `s` an ASCII representation (as produced by ascii_dump(std::ostream&) const) and sets `*this` accordingly. Returns `true` if successful, `false` otherwise.
memory_size_type | total_memory_in_bytes () const
| Returns the total size in bytes of the memory occupied by `*this`.
memory_size_type | external_memory_in_bytes () const
| Returns the size in bytes of the memory managed by `*this`.
int32_t | hash_code () const
| Returns a 32-bit hash code for `*this`.

## Additional Inherited Members
Public Types inherited from Parma_Polyhedra_Library::Polyhedron
typedef Coefficient | coefficient_type
| The numeric type of coefficients.
Static Public Member Functions inherited from Parma_Polyhedra_Library::Polyhedron
static dimension_type | max_space_dimension ()
| Returns the maximum space dimension all kinds of Polyhedron can handle.
static bool | can_recycle_constraint_systems ()
| Returns `true` indicating that this domain has methods that can recycle constraints.
static void | initialize ()
| Initializes the class.
static void | finalize ()
| Finalizes the class.
static bool | can_recycle_congruence_systems ()
| Returns `false` indicating that this domain cannot recycle congruences.
Protected Member Functions inherited from Parma_Polyhedra_Library::Polyhedron
| Polyhedron (Topology topol, dimension_type num_dimensions, Degenerate_Element kind)
| Builds a polyhedron having the specified properties.
| Polyhedron (const Polyhedron &y, Complexity_Class complexity=ANY_COMPLEXITY)
| Ordinary copy constructor.
| Polyhedron (Topology topol, const Constraint_System &cs)
| Builds a polyhedron from a system of constraints.
| Polyhedron (Topology topol, Constraint_System &cs, Recycle_Input dummy)
| Builds a polyhedron recycling a system of constraints.
| Polyhedron (Topology topol, const Generator_System &gs)
| Builds a polyhedron from a system of generators.
| Polyhedron (Topology topol, Generator_System &gs, Recycle_Input dummy)
| Builds a polyhedron recycling a system of generators.
template<typename Interval >
| Polyhedron (Topology topol, const Box< Interval > &box, Complexity_Class complexity=ANY_COMPLEXITY)
| Builds a polyhedron from a box.
Polyhedron & | operator= (const Polyhedron &y)
| The assignment operator. (`*this` and `y` can be dimension-incompatible.)
void | drop_some_non_integer_points (const Variables_Set *vars_p, Complexity_Class complexity)
| Possibly tightens `*this` by dropping some points with non-integer coordinates for the space dimensions corresponding to `*vars_p`.
template<typename FP_Format , typename Interval_Info >
void | overapproximate_linear_form (const Linear_Form< Interval< FP_Format, Interval_Info > > &lf, const dimension_type lf_dimension, Linear_Form< Interval< FP_Format, Interval_Info > > &result)
| Helper function that overapproximates an interval linear form.
Static Protected Member Functions inherited from Parma_Polyhedra_Library::Polyhedron
template<typename FP_Format , typename Interval_Info >
static void | convert_to_integer_expression (const Linear_Form< Interval< FP_Format, Interval_Info > > &lf, const dimension_type lf_dimension, Linear_Expression &result)
| Helper function that makes `result` become a Linear_Expression obtained by normalizing the denominators in `lf`.
template<typename FP_Format , typename Interval_Info >
static void | convert_to_integer_expressions (const Linear_Form< Interval< FP_Format, Interval_Info > > &lf, const dimension_type lf_dimension, Linear_Expression &res, Coefficient &res_low_coeff, Coefficient &res_hi_coeff, Coefficient &denominator)
| Normalization helper function.
Related Functions inherited from Parma_Polyhedra_Library::Polyhedron
std::ostream & | operator<< (std::ostream &s, const Polyhedron &ph)
| Output operator.
void | swap (Polyhedron &x, Polyhedron &y)
| Swaps `x` with `y`.
bool | operator== (const Polyhedron &x, const Polyhedron &y)
| Returns `true` if and only if `x` and `y` are the same polyhedron.
bool | operator!= (const Polyhedron &x, const Polyhedron &y)
| Returns `true` if and only if `x` and `y` are different polyhedra.
void | swap (Polyhedron &x, Polyhedron &y)
bool | operator!= (const Polyhedron &x, const Polyhedron &y)

## Detailed Description

A not necessarily closed convex polyhedron.

An object of the class NNC_Polyhedron represents a not necessarily closed (NNC) convex polyhedron in the vector space .

Note:
  Since NNC polyhedra are a generalization of closed polyhedra, any object of the class C_Polyhedron can be (explicitly) converted into an object of the class NNC_Polyhedron. The reason for defining two different classes is that objects of the class C_Polyhedron are characterized by a more efficient implementation, requiring less time and memory resources.

## Constructor & Destructor Documentation

Parma_Polyhedra_Library::NNC_Polyhedron::NNC_Polyhedron | ( | dimension_type | num_dimensions = `0`,
|  | Degenerate_Element | kind = `UNIVERSE`
| ) |  |
| inline explicit

Builds either the universe or the empty NNC polyhedron.

Parameters:

  num_dimensions | The number of dimensions of the vector space enclosing the NNC polyhedron;
  kind | Specifies whether a universe or an empty NNC polyhedron should be built.

Exceptions:

  std::length_error | Thrown if `num_dimensions` exceeds the maximum allowed space dimension.

Both parameters are optional: by default, a 0-dimension space universe NNC polyhedron is built.

Parma_Polyhedra_Library::NNC_Polyhedron::NNC_Polyhedron | ( | const Constraint_System & | cs | ) |
| inline explicit

Builds an NNC polyhedron from a system of constraints.

The polyhedron inherits the space dimension of the constraint system.

Parameters:

  cs | The system of constraints defining the polyhedron.

Parma_Polyhedra_Library::NNC_Polyhedron::NNC_Polyhedron | ( | Constraint_System & | cs,
|  | Recycle_Input | dummy
| ) |  |
| inline

Builds an NNC polyhedron recycling a system of constraints.

The polyhedron inherits the space dimension of the constraint system.

Parameters:

  cs | The system of constraints defining the polyhedron. It is not declared `const` because its data-structures may be recycled to build the polyhedron.
  dummy | A dummy tag to syntactically differentiate this one from the other constructors.

Parma_Polyhedra_Library::NNC_Polyhedron::NNC_Polyhedron | ( | const Generator_System & | gs | ) |
| inline explicit

Builds an NNC polyhedron from a system of generators.

The polyhedron inherits the space dimension of the generator system.

Parameters:

  gs | The system of generators defining the polyhedron.

Exceptions:

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

Parma_Polyhedra_Library::NNC_Polyhedron::NNC_Polyhedron | ( | Generator_System & | gs,
|  | Recycle_Input | dummy
| ) |  |
| inline

Builds an NNC polyhedron recycling a system of generators.

The polyhedron inherits the space dimension of the generator system.

Parameters:

  gs | The system of generators defining the polyhedron. It is not declared `const` because its data-structures may be recycled to build the polyhedron.
  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.

Parma_Polyhedra_Library::NNC_Polyhedron::NNC_Polyhedron | ( | const Congruence_System & | cgs | ) |
| explicit

Builds an NNC polyhedron from a system of congruences.

The polyhedron inherits the space dimension of the congruence system.

Parameters:

  cgs | The system of congruences defining the polyhedron. It is not declared `const` because its data-structures may be recycled to build the polyhedron.

Parma_Polyhedra_Library::NNC_Polyhedron::NNC_Polyhedron | ( | Congruence_System & | cgs,
|  | Recycle_Input | dummy
| ) |  |

Builds an NNC polyhedron recycling a system of congruences.

The polyhedron inherits the space dimension of the congruence system.

Parameters:

  cgs | The system of congruences defining the polyhedron. It is not declared `const` because its data-structures may be recycled to build the polyhedron.
  dummy | A dummy tag to syntactically differentiate this one from the other constructors.

Parma_Polyhedra_Library::NNC_Polyhedron::NNC_Polyhedron | ( | const C_Polyhedron & | y,
|  | Complexity_Class | complexity = `ANY_COMPLEXITY`
| ) |  |
| explicit

Builds an NNC polyhedron from the C polyhedron `y`.

Parameters:

  y | The C polyhedron to be used;
  complexity | This argument is ignored.

template<typename Interval >

Parma_Polyhedra_Library::NNC_Polyhedron::NNC_Polyhedron | ( | const Box< Interval > & | box,
|  | Complexity_Class | complexity = `ANY_COMPLEXITY`
| ) |  |
| inline explicit

Builds an NNC polyhedron out of a box.

The polyhedron inherits the space dimension of the box and is the most precise that includes the box.

Parameters:

  box | The box representing the polyhedron to be built;
  complexity | This argument is ignored as the algorithm used has polynomial complexity.

Exceptions:

  std::length_error | Thrown if the space dimension of `box` exceeds the maximum allowed space dimension.

Parma_Polyhedra_Library::NNC_Polyhedron::NNC_Polyhedron | ( | const Grid & | grid,
|  | Complexity_Class | complexity = `ANY_COMPLEXITY`
| ) |  |
| explicit

Builds an NNC polyhedron out of a grid.

The polyhedron inherits the space dimension of the grid and is the most precise that includes the grid.

Parameters:

  grid | The grid used to build the polyhedron.
  complexity | This argument is ignored as the algorithm used has polynomial complexity.

template<typename U >

Parma_Polyhedra_Library::NNC_Polyhedron::NNC_Polyhedron | ( | const BD_Shape< U > & | bd,
|  | Complexity_Class | complexity = `ANY_COMPLEXITY`
| ) |  |
| inline explicit

Builds a NNC polyhedron out of a BD shape.

The polyhedron inherits the space dimension of the BD shape and is the most precise that includes the BD shape.

Parameters:

  bd | The BD shape used to build the polyhedron.
  complexity | This argument is ignored as the algorithm used has polynomial complexity.

template<typename U >

Parma_Polyhedra_Library::NNC_Polyhedron::NNC_Polyhedron | ( | const Octagonal_Shape< U > & | os,
|  | Complexity_Class | complexity = `ANY_COMPLEXITY`
| ) |  |
| inline explicit

Builds a NNC polyhedron out of an octagonal shape.

The polyhedron inherits the space dimension of the octagonal shape and is the most precise that includes the octagonal shape.

Parameters:

  os | The octagonal shape used to build the polyhedron.
  complexity | This argument is ignored as the algorithm used has polynomial complexity.

## Member Function Documentation

bool Parma_Polyhedra_Library::NNC_Polyhedron::poly_hull_assign_if_exact | ( | const NNC_Polyhedron & | y | ) |

If the poly-hull 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.

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

- ppl.hh