A linear equality or inequality. More...

#include <Constraint_defs.hh>

Collaboration diagram for Parma_Polyhedra_Library::Constraint:

Public Types
enum	Type { EQUALITY, NONSTRICT_INEQUALITY, STRICT_INEQUALITY }
	The constraint type. More...

typedef Expression_Hide_Last< Linear_Expression >	expr_type
	The type of the (adapted) internal expression. More...

Public Member Functions
	Constraint (Representation r=default_representation)
	Constructs the constraint. More...

	Constraint (const Constraint &c)
	Ordinary copy constructor. More...

	Constraint (const Constraint &c, dimension_type space_dim)
	Copy constructor with given size. More...

	Constraint (const Constraint &c, Representation r)
	Copy constructor with given representation. More...

	Constraint (const Constraint &c, dimension_type space_dim, Representation r)
	Copy constructor with given size and representation. More...

	Constraint (const Congruence &cg, Representation r=default_representation)
	Copy-constructs from equality congruence `cg`. More...

	~Constraint ()
	Destructor. More...

Representation	representation () const
	Returns the current representation of *this. More...

void	set_representation (Representation r)
	Converts *this to the specified representation. More...

Constraint &	operator= (const Constraint &c)
	Assignment operator. More...

dimension_type	space_dimension () const
	Returns the dimension of the vector space enclosing `*this`. More...

void	set_space_dimension (dimension_type space_dim)

void	swap_space_dimensions (Variable v1, Variable v2)
	Swaps the coefficients of the variables `v1` and `v2` . More...

bool	remove_space_dimensions (const Variables_Set &vars)
	Removes all the specified dimensions from the constraint. More...

void	permute_space_dimensions (const std::vector< Variable > &cycle)
	Permutes the space dimensions of the constraint. More...

void	shift_space_dimensions (Variable v, dimension_type n)

Type	type () const
	Returns the constraint type of `*this`. More...

bool	is_equality () const
	Returns `true` if and only if `*this` is an equality constraint. More...

bool	is_inequality () const
	Returns `true` if and only if `*this` is an inequality constraint (either strict or non-strict). More...

bool	is_nonstrict_inequality () const
	Returns `true` if and only if `*this` is a non-strict inequality constraint. More...

bool	is_strict_inequality () const
	Returns `true` if and only if `*this` is a strict inequality constraint. More...

Coefficient_traits::const_reference	coefficient (Variable v) const
	Returns the coefficient of `v` in `*this`. More...

Coefficient_traits::const_reference	inhomogeneous_term () const
	Returns the inhomogeneous term of `*this`. More...

memory_size_type	total_memory_in_bytes () const
	Returns a lower bound to the total size in bytes of the memory occupied by `*this`. More...

memory_size_type	external_memory_in_bytes () const
	Returns the size in bytes of the memory managed by `*this`. More...

bool	is_tautological () const
	Returns `true` if and only if `*this` is a tautology (i.e., an always true constraint). More...

bool	is_inconsistent () const
	Returns `true` if and only if `*this` is inconsistent (i.e., an always false constraint). More...

bool	is_equivalent_to (const Constraint &y) const
	Returns `true` if and only if `*this` and `y` are equivalent constraints. More...

bool	is_equal_to (const Constraint &y) const
	Returns `true` if `*this` is identical to `y`. More...

bool	OK () const
	Checks if all the invariants are satisfied. More...

void	ascii_dump () const
	Writes to `std::cerr` an ASCII representation of `*this`. More...

void	ascii_dump (std::ostream &s) const
	Writes to `s` an ASCII representation of `*this`. More...

void	print () const
	Prints `*this` to `std::cerr` using `operator<<`. More...

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

void	m_swap (Constraint &y)
	Swaps `*this` with `y`. More...

expr_type	expression () const
	Partial read access to the (adapted) internal expression. More...

Static Public Member Functions
static dimension_type	max_space_dimension ()
	Returns the maximum space dimension a Constraint can handle. More...

static void	initialize ()
	Initializes the class. More...

static void	finalize ()
	Finalizes the class. More...

static const Constraint &	zero_dim_false ()
	The unsatisfiable (zero-dimension space) constraint . More...

static const Constraint &	zero_dim_positivity ()
	The true (zero-dimension space) constraint $0 \leq 1$ , also known as positivity constraint. More...

static const Constraint &	epsilon_geq_zero ()
	Returns the zero-dimension space constraint $\epsilon \geq 0$ . More...

static const Constraint &	epsilon_leq_one ()
	The zero-dimension space constraint $\epsilon \leq 1$ (used to implement NNC polyhedra). More...

Static Public Attributes
static const Representation	default_representation = SPARSE
	The representation used for new Constraints. More...

Private Types
enum	Kind { LINE_OR_EQUALITY = 0, RAY_OR_POINT_OR_INEQUALITY = 1 }
	The possible kinds of Constraint objects. More...

Private Member Functions
	Constraint (dimension_type space_dim, Kind kind, Topology topology, Representation r=default_representation)
	Constructs the constraint. More...

	Constraint (Linear_Expression &e, Kind kind, Topology topology)
	Builds a constraint of kind `kind` and topology `topology`, stealing the coefficients from `e`. More...

	Constraint (Linear_Expression &e, Type type, Topology topology)
	Builds a constraint of type `type` and topology `topology`, stealing the coefficients from `e`. More...

bool	is_line_or_equality () const
	Returns `true` if and only if `*this` row represents a line or an equality. More...

bool	is_ray_or_point_or_inequality () const
	Returns `true` if and only if `*this` row represents a ray, a point or an inequality. More...

void	set_is_line_or_equality ()
	Sets to `LINE_OR_EQUALITY` the kind of `*this` row. More...

void	set_is_ray_or_point_or_inequality ()
	Sets to `RAY_OR_POINT_OR_INEQUALITY` the kind of `*this` row. More...

void	set_space_dimension_no_ok (dimension_type space_dim)

void	throw_invalid_argument (const char method, const char message) const
	Throws a `std::invalid_argument` exception containing error message `message`. More...

void	throw_dimension_incompatible (const char method, const char name_var, Variable v) const
	Throws a `std::invalid_argument` exception containing the appropriate error message. More...

Coefficient_traits::const_reference	epsilon_coefficient () const
	Returns the epsilon coefficient. The constraint must be NNC. More...

void	set_epsilon_coefficient (Coefficient_traits::const_reference n)
	Sets the epsilon coefficient to `n`. The constraint must be NNC. More...

void	mark_as_necessarily_closed ()
	Marks the epsilon dimension as a standard dimension. More...

void	mark_as_not_necessarily_closed ()
	Marks the last dimension as the epsilon dimension. More...

void	set_is_equality ()
	Sets the constraint type to `EQUALITY`. More...

void	set_is_inequality ()
	Sets the constraint to be an inequality. More...

void	linear_combine (const Constraint &y, dimension_type i)
	Linearly combines `*this` with `y` so that i-th coefficient is 0. More...

void	sign_normalize ()
	Normalizes the sign of the coefficients so that the first non-zero (homogeneous) coefficient of a line-or-equality is positive. More...

void	strong_normalize ()
	Strong normalization: ensures that different Constraint objects represent different hyperplanes or hyperspaces. More...

bool	check_strong_normalized () const
	Returns `true` if and only if the coefficients are strongly normalized. More...

Flags inspection methods
Topology	topology () const
	Returns the topological kind of `*this`. More...

bool	is_not_necessarily_closed () const
	Returns `true` if and only if the topology of `*this` row is not necessarily closed. More...

bool	is_necessarily_closed () const
	Returns `true` if and only if the topology of `*this` row is necessarily closed. More...

Flags coercion methods
void	set_topology (Topology x)
	Sets to `x` the topological kind of `*this` row. More...

void	set_necessarily_closed ()
	Sets to `NECESSARILY_CLOSED` the topological kind of `*this` row. More...

void	set_not_necessarily_closed ()
	Sets to `NOT_NECESSARILY_CLOSED` the topological kind of `*this` row. More...

Static Private Member Functions
static Constraint	construct_epsilon_geq_zero ()
	Builds a new copy of the zero-dimension space constraint $\epsilon \geq 0$ (used to implement NNC polyhedra). More...

Private Attributes
Linear_Expression	expr

Kind	kind_

Topology	topology_

Static Private Attributes
static const Constraint *	zero_dim_false_p = 0
	Holds (between class initialization and finalization) a pointer to the unsatisfiable (zero-dimension space) constraint . More...

static const Constraint *	zero_dim_positivity_p = 0
	Holds (between class initialization and finalization) a pointer to the true (zero-dimension space) constraint $0 \leq 1$ , also known as positivity constraint. More...

static const Constraint *	epsilon_geq_zero_p = 0
	Holds (between class initialization and finalization) a pointer to the zero-dimension space constraint $\epsilon \geq 0$ . More...

static const Constraint *	epsilon_leq_one_p = 0
	Holds (between class initialization and finalization) a pointer to the zero-dimension space constraint $\epsilon \leq 1$ (used to implement NNC polyhedra). More...

Friends
class	Linear_System< Constraint >

class	Constraint_System

class	Polyhedron

class	Scalar_Products

class	Topology_Adjusted_Scalar_Product_Sign

class	Termination_Helpers

class	Grid

template<typename T >
class	Octagonal_Shape

int	compare (const Constraint &x, const Constraint &y)

Constraint	operator< (const Linear_Expression &e1, const Linear_Expression &e2)

Constraint	operator< (Variable v1, Variable v2)

Constraint	operator< (const Linear_Expression &e, Coefficient_traits::const_reference n)

Constraint	operator< (Coefficient_traits::const_reference n, const Linear_Expression &e)

Constraint	operator> (const Linear_Expression &e1, const Linear_Expression &e2)

Constraint	operator> (Variable v1, Variable v2)

Constraint	operator> (const Linear_Expression &e, Coefficient_traits::const_reference n)

Constraint	operator> (Coefficient_traits::const_reference n, const Linear_Expression &e)

Constraint	operator== (const Linear_Expression &e1, const Linear_Expression &e2)

Constraint	operator== (Variable v1, Variable v2)

Constraint	operator== (const Linear_Expression &e, Coefficient_traits::const_reference n)

Constraint	operator== (Coefficient_traits::const_reference n, const Linear_Expression &e)

Constraint	operator<= (const Linear_Expression &e1, const Linear_Expression &e2)

Constraint	operator<= (Variable v1, Variable v2)

Constraint	operator<= (const Linear_Expression &e, Coefficient_traits::const_reference n)

Constraint	operator<= (Coefficient_traits::const_reference n, const Linear_Expression &e)

Constraint	operator>= (const Linear_Expression &e1, const Linear_Expression &e2)

Constraint	operator>= (Variable v1, Variable v2)

Constraint	operator>= (const Linear_Expression &e, Coefficient_traits::const_reference n)

Constraint	operator>= (Coefficient_traits::const_reference n, const Linear_Expression &e)

Related Functions
(Note that these are not member functions.)
int	compare (const Constraint &x, const Constraint &y)

std::ostream &	operator<< (std::ostream &s, const Constraint &c)

std::ostream &	operator<< (std::ostream &s, const Constraint::Type &t)

Constraint	operator< (const Linear_Expression &e1, const Linear_Expression &e2)
	Returns the constraint `e1` < `e2`. More...

Constraint	operator< (Variable v1, Variable v2)
	Returns the constraint `v1` < `v2`. More...

Constraint	operator< (const Linear_Expression &e, Coefficient_traits::const_reference n)
	Returns the constraint `e` < `n`. More...

Constraint	operator< (Coefficient_traits::const_reference n, const Linear_Expression &e)
	Returns the constraint `n` < `e`. More...

Constraint	operator> (const Linear_Expression &e1, const Linear_Expression &e2)
	Returns the constraint `e1` > `e2`. More...

Constraint	operator> (Variable v1, Variable v2)
	Returns the constraint `v1` > `v2`. More...

Constraint	operator> (const Linear_Expression &e, Coefficient_traits::const_reference n)
	Returns the constraint `e` > `n`. More...

Constraint	operator> (Coefficient_traits::const_reference n, const Linear_Expression &e)
	Returns the constraint `n` > `e`. More...

Constraint	operator== (const Linear_Expression &e1, const Linear_Expression &e2)
	Returns the constraint `e1` = `e2`. More...

Constraint	operator== (Variable v1, Variable v2)
	Returns the constraint `v1` = `v2`. More...

Constraint	operator== (const Linear_Expression &e, Coefficient_traits::const_reference n)
	Returns the constraint `e` = `n`. More...

Constraint	operator== (Coefficient_traits::const_reference n, const Linear_Expression &e)
	Returns the constraint `n` = `e`. More...

Constraint	operator<= (const Linear_Expression &e1, const Linear_Expression &e2)
	Returns the constraint `e1` <= `e2`. More...

Constraint	operator<= (Variable v1, Variable v2)
	Returns the constraint `v1` <= `v2`. More...

Constraint	operator<= (const Linear_Expression &e, Coefficient_traits::const_reference n)
	Returns the constraint `e` <= `n`. More...

Constraint	operator<= (Coefficient_traits::const_reference n, const Linear_Expression &e)
	Returns the constraint `n` <= `e`. More...

Constraint	operator>= (const Linear_Expression &e1, const Linear_Expression &e2)
	Returns the constraint `e1` >= `e2`. More...

Constraint	operator>= (Variable v1, Variable v2)
	Returns the constraint `v1` >= `v2`. More...

Constraint	operator>= (const Linear_Expression &e, Coefficient_traits::const_reference n)
	Returns the constraint `e` >= `n`. More...

Constraint	operator>= (Coefficient_traits::const_reference n, const Linear_Expression &e)
	Returns the constraint `n` >= `e`. More...

int	compare (const Constraint &x, const Constraint &y)
	The basic comparison function. More...

std::ostream &	operator<< (std::ostream &s, const Constraint &c)
	Output operator. More...

std::ostream &	operator<< (std::ostream &s, const Constraint::Type &t)
	Output operator. More...

bool	operator== (const Constraint &x, const Constraint &y)
	Returns `true` if and only if `x` is equivalent to `y`. More...

bool	operator!= (const Constraint &x, const Constraint &y)
	Returns `true` if and only if `x` is not equivalent to `y`. More...

void	swap (Constraint &x, Constraint &y)

bool	operator== (const Constraint &x, const Constraint &y)

bool	operator!= (const Constraint &x, const Constraint &y)

Constraint	operator== (const Linear_Expression &e1, const Linear_Expression &e2)

Constraint	operator== (Variable v1, Variable v2)

Constraint	operator>= (const Linear_Expression &e1, const Linear_Expression &e2)

Constraint	operator>= (const Variable v1, const Variable v2)

Constraint	operator> (const Linear_Expression &e1, const Linear_Expression &e2)

Constraint	operator> (const Variable v1, const Variable v2)

Constraint	operator== (Coefficient_traits::const_reference n, const Linear_Expression &e)

Constraint	operator>= (Coefficient_traits::const_reference n, const Linear_Expression &e)

Constraint	operator> (Coefficient_traits::const_reference n, const Linear_Expression &e)

Constraint	operator== (const Linear_Expression &e, Coefficient_traits::const_reference n)

Constraint	operator>= (const Linear_Expression &e, Coefficient_traits::const_reference n)

Constraint	operator> (const Linear_Expression &e, Coefficient_traits::const_reference n)

Constraint	operator<= (const Linear_Expression &e1, const Linear_Expression &e2)

Constraint	operator<= (const Variable v1, const Variable v2)

Constraint	operator<= (Coefficient_traits::const_reference n, const Linear_Expression &e)

Constraint	operator<= (const Linear_Expression &e, Coefficient_traits::const_reference n)

Constraint	operator< (const Linear_Expression &e1, const Linear_Expression &e2)

Constraint	operator< (const Variable v1, const Variable v2)

Constraint	operator< (Coefficient_traits::const_reference n, const Linear_Expression &e)

Constraint	operator< (const Linear_Expression &e, Coefficient_traits::const_reference n)

void	swap (Constraint &x, Constraint &y)

Detailed Description

A linear equality or inequality.

An object of the class Constraint is either:

an equality: $\sum_{i=0}^{n-1} a_i x_i + b = 0$ ;
a non-strict inequality: $\sum_{i=0}^{n-1} a_i x_i + b \geq 0$ ; or
a strict inequality: $\sum_{i=0}^{n-1} a_i x_i + b > 0$ ;

where $n$ is the dimension of the space, $a_i$ is the integer coefficient of variable $x_i$ and $b$ is the integer inhomogeneous term.

How to build a constraint: Constraints are typically built by applying a relation symbol to a pair of linear expressions. Available relation symbols are equality (==), non-strict inequalities (>= and <=) and strict inequalities (< and >). The space dimension of a constraint is defined as the maximum space dimension of the arguments of its constructor.

: In the following examples it is assumed that variables x, y and z are defined as follows:
Variable x(0);

Variable y(1);

Variable z(2);

Example 1: The following code builds the equality constraint , having space dimension :
Constraint eq_c(3*x + 5*y - z == 0);

The following code builds the (non-strict) inequality constraint $4x \geq 2y - 13$ , having space dimension :
Constraint ineq_c(4*x >= 2*y - 13);

The corresponding strict inequality constraint is obtained as follows:
Constraint strict_ineq_c(4*x > 2*y - 13);

An unsatisfiable constraint on the zero-dimension space $\Rset^0$ can be specified as follows:
Constraint false_c = Constraint::zero_dim_false();

Equivalent, but more involved ways are the following:
Constraint false_c1(Linear_Expression::zero() == 1);

Constraint false_c2(Linear_Expression::zero() >= 1);

Constraint false_c3(Linear_Expression::zero() > 0);

In contrast, the following code defines an unsatisfiable constraint having space dimension :
Constraint false_c(0*z == 1);

How to inspect a constraint: Several methods are provided to examine a constraint and extract all the encoded information: its space dimension, its type (equality, non-strict inequality, strict inequality) and the value of its integer coefficients.

Example 2: The following code shows how it is possible to access each single coefficient of a constraint. Given an inequality constraint (in this case $x - 5y + 3z \leq 4$ ), we construct a new constraint corresponding to its complement (thus, in this case we want to obtain the strict inequality constraint ).
Constraint c1(x - 5*y + 3*z <= 4);

cout << "Constraint c1: " << c1 << endl;

if (c1.is_equality())

cout << "Constraint c1 is not an inequality." << endl;

else {

Linear_Expression e;

for (dimension_type i = c1.space_dimension(); i-- > 0; )

e += c1.coefficient(Variable(i)) * Variable(i);

e += c1.inhomogeneous_term();

Constraint c2 = c1.is_strict_inequality() ? (e <= 0) : (e < 0);

cout << "Complement c2: " << c2 << endl;

}

The actual output is the following:
Constraint c1: -A + 5*B - 3*C >= -4

Complement c2: A - 5*B + 3*C > 4

Note that, in general, the particular output obtained can be syntactically different from the (semantically equivalent) constraint considered.

Definition at line 284 of file Constraint_defs.hh.

Member Typedef Documentation

typedef Expression_Hide_Last<Linear_Expression> Parma_Polyhedra_Library::Constraint::expr_type

The type of the (adapted) internal expression.

Definition at line 521 of file Constraint_defs.hh.

Constructor & Destructor Documentation

Parma_Polyhedra_Library::Constraint::Constraint ( Representation r = default_representation )

inlineexplicit

Constructs the $0<=0$ constraint.

Definition at line 120 of file Constraint_inlines.hh.

References OK().

   : expr(r),
     kind_(RAY_OR_POINT_OR_INEQUALITY),
     topology_(NECESSARILY_CLOSED) {
   PPL_ASSERT(OK());
 }

Parma_Polyhedra_Library::Constraint::Constraint ( const Constraint & c )

inline

Ordinary copy constructor.

Note: The new Constraint will have the same representation as `c', not default_representation, so that they are indistinguishable.

Definition at line 171 of file Constraint_inlines.hh.

   : expr(c.expr),
     kind_(c.kind_),
     topology_(c.topology_) {
   // NOTE: This does not call PPL_ASSERT(OK()) because this is called by OK().
 }

Parma_Polyhedra_Library::Constraint::Constraint	(	const Constraint &	c,
		dimension_type	space_dim
	)

inline

Copy constructor with given size.

Note: The new Constraint will have the same representation as `c', not default_representation, so that they are indistinguishable.

Definition at line 187 of file Constraint_inlines.hh.

References OK(), and space_dimension().

   : expr(c.expr, c.is_necessarily_closed() ? space_dim : (space_dim + 1)),
     kind_(c.kind_), topology_(c.topology_) {
   PPL_ASSERT(space_dimension() == space_dim);
   PPL_ASSERT(OK());
 }

Parma_Polyhedra_Library::Constraint::Constraint	(	const Constraint &	c,
		Representation	r
	)

inline

Copy constructor with given representation.

Definition at line 179 of file Constraint_inlines.hh.

References OK().

   : expr(c.expr, r),
     kind_(c.kind_),
     topology_(c.topology_) {
   PPL_ASSERT(OK());
 }

Parma_Polyhedra_Library::Constraint::Constraint	(	const Constraint &	c,
		dimension_type	space_dim,
		Representation	r
	)

inline

Copy constructor with given size and representation.

Definition at line 195 of file Constraint_inlines.hh.

References OK(), and space_dimension().

   : expr(c.expr, c.is_necessarily_closed() ? space_dim : (space_dim + 1), r),
     kind_(c.kind_), topology_(c.topology_) {
   PPL_ASSERT(space_dimension() == space_dim);
   PPL_ASSERT(OK());
 }

Parma_Polyhedra_Library::Constraint::Constraint	(	const Congruence &	cg,
		Representation	r = `default_representation`
	)

explicit

Copy-constructs from equality congruence cg.

Exceptions

std::invalid_argument Thrown if cg is a proper congruence.

Definition at line 66 of file Constraint.cc.

References Parma_Polyhedra_Library::Congruence::is_equality(), OK(), strong_normalize(), and throw_invalid_argument().

   : expr(cg.expression(), r),
     kind_(LINE_OR_EQUALITY),
     topology_(NECESSARILY_CLOSED) {
   if (!cg.is_equality()) {
     throw_invalid_argument("Constraint(cg)",
                            "congruence cg must be an equality.");
   }
   // Enforce normalization.
   strong_normalize();
   PPL_ASSERT(OK());
 }

Parma_Polyhedra_Library::Constraint::~Constraint ( )

inline

Destructor.

Definition at line 204 of file Constraint_inlines.hh.

204 {

205 }

Parma_Polyhedra_Library::Constraint::Constraint	(	dimension_type	space_dim,
		Kind	kind,
		Topology	topology,
		Representation	r = `default_representation`
	)

inlineprivate

Constructs the $0<0$ constraint.

Definition at line 128 of file Constraint_inlines.hh.

References expr, OK(), Parma_Polyhedra_Library::Linear_Expression::set_space_dimension(), and space_dimension().

   : expr(r),
     kind_(kind),
     topology_(topology) {
   expr.set_space_dimension(space_dim + 1);
   PPL_ASSERT(space_dimension() == space_dim);
   PPL_ASSERT(OK());
 }

Parma_Polyhedra_Library::Constraint::Constraint	(	Linear_Expression &	e,
		Kind	kind,
		Topology	topology
	)

inlineprivate

Builds a constraint of kind kind and topology topology, stealing the coefficients from e.

Note: The new Constraint will have the same representation as `e'.

Definition at line 139 of file Constraint_inlines.hh.

References expr, Parma_Polyhedra_Library::NOT_NECESSARILY_CLOSED, OK(), RAY_OR_POINT_OR_INEQUALITY, Parma_Polyhedra_Library::Linear_Expression::set_space_dimension(), Parma_Polyhedra_Library::Linear_Expression::space_dimension(), strong_normalize(), and swap().

   : kind_(kind),
     topology_(topology) {
   PPL_ASSERT(kind != RAY_OR_POINT_OR_INEQUALITY || topology == NOT_NECESSARILY_CLOSED);
   swap(expr, e);
   if (topology == NOT_NECESSARILY_CLOSED) {
     // Add the epsilon dimension.
     expr.set_space_dimension(expr.space_dimension() + 1);
   }
   strong_normalize();
   PPL_ASSERT(OK());
 }

Parma_Polyhedra_Library::Constraint::Constraint	(	Linear_Expression &	e,
		Type	type,
		Topology	topology
	)

inlineprivate

Builds a constraint of type type and topology topology, stealing the coefficients from e.

Note: The new Constraint will have the same representation as `e'.

Definition at line 153 of file Constraint_inlines.hh.

References EQUALITY, expr, kind_, LINE_OR_EQUALITY, Parma_Polyhedra_Library::NOT_NECESSARILY_CLOSED, OK(), RAY_OR_POINT_OR_INEQUALITY, Parma_Polyhedra_Library::Linear_Expression::set_space_dimension(), Parma_Polyhedra_Library::Linear_Expression::space_dimension(), STRICT_INEQUALITY, strong_normalize(), and swap().

   : topology_(topology) {
   PPL_ASSERT(type != STRICT_INEQUALITY || topology == NOT_NECESSARILY_CLOSED);
   swap(expr, e);
   if (topology == NOT_NECESSARILY_CLOSED) {
     expr.set_space_dimension(expr.space_dimension() + 1);
   }
   if (type == EQUALITY) {
     kind_ = LINE_OR_EQUALITY;
   }
   else {
     kind_ = RAY_OR_POINT_OR_INEQUALITY;
   }
   strong_normalize();
   PPL_ASSERT(OK());
 }

Member Function Documentation

void Parma_Polyhedra_Library::Constraint::ascii_dump ( ) const

Writes to std::cerr an ASCII representation of *this.

void Parma_Polyhedra_Library::Constraint::ascii_dump ( std::ostream & s ) const

Writes to s an ASCII representation of *this.

Definition at line 309 of file Constraint.cc.

References EQUALITY, Parma_Polyhedra_Library::NECESSARILY_CLOSED, NONSTRICT_INEQUALITY, and STRICT_INEQUALITY.

                                              {
   expr.ascii_dump(s);
 
   s << " ";
 
   switch (type()) {
   case Constraint::EQUALITY:
     s << "=";
     break;
   case Constraint::NONSTRICT_INEQUALITY:
     s << ">=";
     break;
   case Constraint::STRICT_INEQUALITY:
     s << ">";
     break;
   }
   s << " ";
   if (topology() == NECESSARILY_CLOSED) {
     s << "(C)";
   }
   else {
     s << "(NNC)";
   }
   s << "\n";
 }

bool Parma_Polyhedra_Library::Constraint::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.

Definition at line 336 of file Constraint.cc.

References Parma_Polyhedra_Library::NECESSARILY_CLOSED, and Parma_Polyhedra_Library::NOT_NECESSARILY_CLOSED.

Referenced by Parma_Polyhedra_Library::MIP_Problem::ascii_load(), and Parma_Polyhedra_Library::PIP_Problem::ascii_load().

                                        {
   std::string str;
   std::string str2;
 
   expr.ascii_load(s);
 
   if (!(s >> str)) {
     return false;
   }
   if (str == "=") {
     set_is_equality();
   }
   else if (str == ">=" || str == ">") {
     set_is_inequality();
   }
   else {
     return false;
   }
 
   if (!(s >> str2)) {
     return false;
   }
   if (str2 == "(NNC)") {
     // TODO: Avoid the mark_as_*() methods if possible.
     if (topology() == NECESSARILY_CLOSED) {
       mark_as_not_necessarily_closed();
     }
   }
   else {
     if (str2 == "(C)") {
       // TODO: Avoid the mark_as_*() methods if possible.
       if (topology() == NOT_NECESSARILY_CLOSED) {
         mark_as_necessarily_closed();
       }
     }
     else {
       return false;
     }
   }
 
   // Checking for equality of actual and declared types.
   switch (type()) {
   case EQUALITY:
     if (str != "=") {
       return false;
     }
     break;
   case NONSTRICT_INEQUALITY:
     if (str != ">=") {
       return false;
     }
     break;
   case STRICT_INEQUALITY:
     if (str != ">") {
       return false;
     }
     break;
   }
 
   return true;
 }

bool Parma_Polyhedra_Library::Constraint::check_strong_normalized ( ) const

private

Returns true if and only if the coefficients are strongly normalized.

Definition at line 259 of file Constraint.cc.

References Parma_Polyhedra_Library::compare(), and strong_normalize().

                                              {
   Constraint tmp = *this;
   tmp.strong_normalize();
   return compare(*this, tmp) == 0;
 }

Coefficient_traits::const_reference Parma_Polyhedra_Library::Constraint::coefficient ( Variable v ) const

inline

Returns the coefficient of v in *this.

Exceptions

std::invalid_argument thrown if the index of v is greater than or equal to the space dimension of *this.

Definition at line 312 of file Constraint_inlines.hh.

References Parma_Polyhedra_Library::Linear_Expression::coefficient(), expr, Parma_Polyhedra_Library::Variable::space_dimension(), space_dimension(), and throw_dimension_incompatible().

                                               {
   if (v.space_dimension() > space_dimension()) {
     throw_dimension_incompatible("coefficient(v)", "v", v);
   }
   return expr.coefficient(v);
 }

PPL::Constraint Parma_Polyhedra_Library::Constraint::construct_epsilon_geq_zero ( )

staticprivate

Builds a new copy of the zero-dimension space constraint $\epsilon \geq 0$ (used to implement NNC polyhedra).

Definition at line 58 of file Constraint.cc.

References c, Parma_Polyhedra_Library::Coefficient_one(), Parma_Polyhedra_Library::NOT_NECESSARILY_CLOSED, OK(), and set_epsilon_coefficient().

                                           {
   Linear_Expression e;
   Constraint c(e, NONSTRICT_INEQUALITY, NOT_NECESSARILY_CLOSED);
   c.set_epsilon_coefficient(Coefficient_one());
   PPL_ASSERT(c.OK());
   return c;
 }

Coefficient_traits::const_reference Parma_Polyhedra_Library::Constraint::epsilon_coefficient ( ) const

inlineprivate

Returns the epsilon coefficient. The constraint must be NNC.

Definition at line 570 of file Constraint_inlines.hh.

References Parma_Polyhedra_Library::Linear_Expression::coefficient(), expr, is_not_necessarily_closed(), and Parma_Polyhedra_Library::Linear_Expression::space_dimension().

Referenced by Parma_Polyhedra_Library::Polyhedron::drop_some_non_integer_points(), Parma_Polyhedra_Library::Constraint_System::has_strict_inequalities(), Parma_Polyhedra_Library::Polyhedron::is_universe(), Parma_Polyhedra_Library::Polyhedron::strongly_minimize_constraints(), Parma_Polyhedra_Library::Polyhedron::topological_closure_assign(), and type().

                                       {
   PPL_ASSERT(is_not_necessarily_closed());
   return expr.coefficient(Variable(expr.space_dimension() - 1));
 }

const Constraint & Parma_Polyhedra_Library::Constraint::epsilon_geq_zero ( )

inlinestatic

Returns the zero-dimension space constraint $\epsilon \geq 0$ .

Definition at line 550 of file Constraint_inlines.hh.

References epsilon_geq_zero_p.

Referenced by Parma_Polyhedra_Library::Constraint_System::add_low_level_constraints().

                              {
   PPL_ASSERT(epsilon_geq_zero_p != 0);
   return *epsilon_geq_zero_p;
 }

const Constraint & Parma_Polyhedra_Library::Constraint::epsilon_leq_one ( )

inlinestatic

The zero-dimension space constraint $\epsilon \leq 1$ (used to implement NNC polyhedra).

Definition at line 556 of file Constraint_inlines.hh.

References epsilon_leq_one_p.

Referenced by Parma_Polyhedra_Library::Constraint_System::add_low_level_constraints(), Parma_Polyhedra_Library::Polyhedron::drop_some_non_integer_points(), Parma_Polyhedra_Library::Polyhedron::strongly_minimize_constraints(), and Parma_Polyhedra_Library::Polyhedron::topological_closure_assign().

                             {
   PPL_ASSERT(epsilon_leq_one_p != 0);
   return *epsilon_leq_one_p;
 }

Constraint::expr_type Parma_Polyhedra_Library::Constraint::expression ( ) const

inline

Partial read access to the (adapted) internal expression.

Definition at line 42 of file Constraint_inlines.hh.

References expr, and is_not_necessarily_closed().

                              {
   return expr_type(expr, is_not_necessarily_closed());
 }

memory_size_type Parma_Polyhedra_Library::Constraint::external_memory_in_bytes ( ) const

inline

Returns the size in bytes of the memory managed by *this.

Definition at line 325 of file Constraint_inlines.hh.

References expr, and Parma_Polyhedra_Library::Linear_Expression::external_memory_in_bytes().

Referenced by total_memory_in_bytes().

                                            {
   return expr.external_memory_in_bytes();
 }

void Parma_Polyhedra_Library::Constraint::finalize ( )

static

Finalizes the class.

Definition at line 290 of file Constraint.cc.

Referenced by Parma_Polyhedra_Library::Init::~Init().

                         {
   PPL_ASSERT(zero_dim_false_p != 0);
   delete zero_dim_false_p;
   zero_dim_false_p = 0;
 
   PPL_ASSERT(zero_dim_positivity_p != 0);
   delete zero_dim_positivity_p;
   zero_dim_positivity_p = 0;
 
   PPL_ASSERT(epsilon_geq_zero_p != 0);
   delete epsilon_geq_zero_p;
   epsilon_geq_zero_p = 0;
 
   PPL_ASSERT(epsilon_leq_one_p != 0);
   delete epsilon_leq_one_p;
   epsilon_leq_one_p = 0;
 }

Coefficient_traits::const_reference Parma_Polyhedra_Library::Constraint::inhomogeneous_term ( ) const

inline

Returns the inhomogeneous term of *this.

Definition at line 320 of file Constraint_inlines.hh.

References expr, and Parma_Polyhedra_Library::Linear_Expression::inhomogeneous_term().

                                      {
   return expr.inhomogeneous_term();
 }

void Parma_Polyhedra_Library::Constraint::initialize ( )

static

Initializes the class.

Definition at line 271 of file Constraint.cc.

References Parma_Polyhedra_Library::Coefficient_one(), and Parma_Polyhedra_Library::Linear_Expression::zero().

Referenced by Parma_Polyhedra_Library::Init::Init().

                           {
   PPL_ASSERT(zero_dim_false_p == 0);
   zero_dim_false_p
     = new Constraint(Linear_Expression::zero() == Coefficient_one());
 
   PPL_ASSERT(zero_dim_positivity_p == 0);
   zero_dim_positivity_p
     = new Constraint(Linear_Expression::zero() <= Coefficient_one());
 
   PPL_ASSERT(epsilon_geq_zero_p == 0);
   epsilon_geq_zero_p
     = new Constraint(construct_epsilon_geq_zero());
 
   PPL_ASSERT(epsilon_leq_one_p == 0);
   epsilon_leq_one_p
     = new Constraint(Linear_Expression::zero() < Coefficient_one());
 }

bool Parma_Polyhedra_Library::Constraint::is_equal_to ( const Constraint & y ) const

Returns true if *this is identical to y.

This is faster than is_equivalent_to(), but it may return `false' even for equivalent constraints.

Definition at line 247 of file Constraint.cc.

References expr, kind_, and topology().

                                                     {
   return expr.is_equal_to(y.expr) && kind_ == y.kind_ && topology() == y.topology();
 }

bool Parma_Polyhedra_Library::Constraint::is_equality ( ) const

inline

Returns true if and only if *this is an equality constraint.

Definition at line 266 of file Constraint_inlines.hh.

References is_line_or_equality().

                               {
   return is_line_or_equality();
 }

bool Parma_Polyhedra_Library::Constraint::is_equivalent_to ( const Constraint & y ) const

Returns true if and only if *this and y are equivalent constraints.

Constraints having different space dimensions are not equivalent. Note that constraints having different types may nonetheless be equivalent, if they both are tautologies or inconsistent.

Definition at line 208 of file Constraint.cc.

References expr, expression(), Parma_Polyhedra_Library::Linear_Expression::is_equal_to(), is_inconsistent(), is_tautological(), Parma_Polyhedra_Library::Linear_Expression::normalize(), space_dimension(), and type().

Referenced by operator!=(), and operator==().

                                                          {
   const Constraint& x = *this;
   const dimension_type x_space_dim = x.space_dimension();
   if (x_space_dim != y.space_dimension()) {
     return false;
   }
 
   const Type x_type = x.type();
   if (x_type != y.type()) {
     // Check for special cases.
     if (x.is_tautological()) {
       return y.is_tautological();
     }
     else {
       return x.is_inconsistent() && y.is_inconsistent();
     }
   }
 
   if (x_type == STRICT_INEQUALITY) {
     // Due to the presence of epsilon-coefficients, syntactically
     // different strict inequalities may actually encode the same
     // topologically open half-space.
     // First, drop the epsilon-coefficient ...
     Linear_Expression x_expr(x.expression());
     Linear_Expression y_expr(y.expression());
     // ... then, re-normalize ...
     x_expr.normalize();
     y_expr.normalize();
     // ... and finally check for syntactic equality.
     return x_expr.is_equal_to(y_expr);
   }
 
   // `x' and 'y' are of the same type and they are not strict inequalities;
   // thus, the epsilon-coefficient, if present, is zero.
   // It is sufficient to check for syntactic equality.
   return x.expr.is_equal_to(y.expr);
 }

bool Parma_Polyhedra_Library::Constraint::is_inconsistent ( ) const

Returns true if and only if *this is inconsistent (i.e., an always false constraint).

An inconsistent constraint can have either one of the following forms:

an equality: $\sum_{i=0}^{n-1} 0 x_i + b = 0$ , where $b \neq 0$ ; or
a non-strict inequality: $\sum_{i=0}^{n-1} 0 x_i + b \geq 0$ , where ; or
a strict inequality: $\sum_{i=0}^{n-1} 0 x_i + b > 0$ , where $b \leq 0$ .

Definition at line 148 of file Constraint.cc.

                                      {
   if (expr.all_homogeneous_terms_are_zero()) {
     // The inhomogeneous term is the only non-zero coefficient.
     if (is_equality()) {
       return expr.inhomogeneous_term() != 0;
     }
     else {
       // Non-strict inequality constraint.
       return expr.inhomogeneous_term() < 0;
     }
   }
   else {
     // There is a non-zero homogeneous coefficient.
     if (is_necessarily_closed()) {
       return false;
     }
     else {
       // The constraint is NOT necessarily closed.
       if (epsilon_coefficient() >= 0) {
         // If positive, we have found the constraint epsilon >= 0.
         // If zero, one of the `true' dimensions has a non-zero coefficient.
         // In both cases, it is not trivially false.
         return false;
       }
       else {
         // Here the epsilon coefficient is negative: strict inequality.
         if (expr.inhomogeneous_term() > 0) {
           // A strict inequality such as `lhs + k > 0',
           // where k is a positive integer, cannot be trivially false.
           return false;
         }
         // Checking for another non-zero coefficient.
         // If the check succeeds, we have the inequality `k > 0',
         // where k is a positive integer.
         return expression().all_homogeneous_terms_are_zero();
       }
     }
   }
 }

bool Parma_Polyhedra_Library::Constraint::is_inequality ( ) const

inline

Returns true if and only if *this is an inequality constraint (either strict or non-strict).

Definition at line 271 of file Constraint_inlines.hh.

References is_ray_or_point_or_inequality().

                                 {
   return is_ray_or_point_or_inequality();
 }

bool Parma_Polyhedra_Library::Constraint::is_line_or_equality ( ) const

inlineprivate

Returns true if and only if *this row represents a line or an equality.

Definition at line 57 of file Constraint_inlines.hh.

References kind_, and LINE_OR_EQUALITY.

Referenced by compare(), and is_equality().

                                       {
   return (kind_ == LINE_OR_EQUALITY);
 }

bool Parma_Polyhedra_Library::Constraint::is_necessarily_closed ( ) const

inlineprivate

Returns true if and only if the topology of *this row is necessarily closed.

Definition at line 32 of file Constraint_inlines.hh.

References Parma_Polyhedra_Library::NECESSARILY_CLOSED, and topology_.

Referenced by is_not_necessarily_closed(), mark_as_not_necessarily_closed(), Parma_Polyhedra_Library::Topology_Adjusted_Scalar_Product_Sign::operator()(), Parma_Polyhedra_Library::Scalar_Products::reduced_sign(), Parma_Polyhedra_Library::Polyhedron::refine_no_check(), Parma_Polyhedra_Library::Polyhedron::refine_with_constraints(), and type().

                                         {
   return (topology_ == NECESSARILY_CLOSED);
 }

bool Parma_Polyhedra_Library::Constraint::is_nonstrict_inequality ( ) const

inline

Returns true if and only if *this is a non-strict inequality constraint.

Definition at line 292 of file Constraint_inlines.hh.

References NONSTRICT_INEQUALITY, and type().

Referenced by Parma_Polyhedra_Library::Octagonal_Shape< T >::relation_with(), and Parma_Polyhedra_Library::BD_Shape< T >::relation_with().

                                           {
   return type() == NONSTRICT_INEQUALITY;
 }

bool Parma_Polyhedra_Library::Constraint::is_not_necessarily_closed ( ) const

inlineprivate

Returns true if and only if the topology of *this row is not necessarily closed.

Definition at line 37 of file Constraint_inlines.hh.

References is_necessarily_closed().

Referenced by epsilon_coefficient(), expression(), mark_as_necessarily_closed(), and set_epsilon_coefficient().

                                             {
   return !is_necessarily_closed();
 }

bool Parma_Polyhedra_Library::Constraint::is_ray_or_point_or_inequality ( ) const

inlineprivate

Returns true if and only if *this row represents a ray, a point or an inequality.

Definition at line 62 of file Constraint_inlines.hh.

References kind_, and RAY_OR_POINT_OR_INEQUALITY.

Referenced by is_inequality().

                                                 {
   return (kind_ == RAY_OR_POINT_OR_INEQUALITY);
 }

bool Parma_Polyhedra_Library::Constraint::is_strict_inequality ( ) const

inline

Returns true if and only if *this is a strict inequality constraint.

Definition at line 297 of file Constraint_inlines.hh.

References STRICT_INEQUALITY, and type().

                                        {
   return type() == STRICT_INEQUALITY;
 }

bool Parma_Polyhedra_Library::Constraint::is_tautological ( ) const

Returns true if and only if *this is a tautology (i.e., an always true constraint).

A tautology can have either one of the following forms:

an equality: $\sum_{i=0}^{n-1} 0 x_i + 0 = 0$ ; or
a non-strict inequality: $\sum_{i=0}^{n-1} 0 x_i + b \geq 0$ , where $b \geq 0$ ; or
a strict inequality: $\sum_{i=0}^{n-1} 0 x_i + b > 0$ , where .

Definition at line 105 of file Constraint.cc.

References Parma_Polyhedra_Library::Boundary_NS::sgn().

                                      {
   if (expr.all_homogeneous_terms_are_zero()) {
     if (is_equality()) {
       return expr.inhomogeneous_term() == 0;
     }
     else {
       // Non-strict inequality constraint.
       return expr.inhomogeneous_term() >= 0;
     }
   }
   else {
     // There is a non-zero homogeneous coefficient.
     if (is_necessarily_closed()) {
       return false;
     }
     else {
       // The constraint is NOT necessarily closed.
       const int eps_sign = sgn(epsilon_coefficient());
       if (eps_sign > 0) {
         // We have found the constraint epsilon >= 0.
         return true;
       }
       if (eps_sign == 0) {
         // One of the `true' dimensions has a non-zero coefficient.
         return false;
       }
       else {
         // Here the epsilon coefficient is negative: strict inequality.
         if (expr.inhomogeneous_term() <= 0) {
           // A strict inequality such as `lhs - k > 0',
           // where k is a non negative integer, cannot be trivially true.
           return false;
         }
         // Checking for another non-zero coefficient.
         // If the check succeeds, we have the inequality `k > 0',
         // where k is a positive integer.
         return expression().all_homogeneous_terms_are_zero();
       }
     }
   }
 }

void Parma_Polyhedra_Library::Constraint::linear_combine	(	const Constraint &	y,
		dimension_type	i
	)

private

Linearly combines *this with y so that i-th coefficient is 0.

Parameters

y	The Constraint that will be combined with `*this` object;
i	The index of the coefficient that has to become .

Computes a linear combination of *this and y having the i-th coefficient equal to $0$ . Then it assigns the resulting Constraint to *this and normalizes it.

Definition at line 189 of file Constraint.cc.

References expr.

                                                                    {
   expr.linear_combine(y.expr, i);
   strong_normalize();
 }

void Parma_Polyhedra_Library::Constraint::m_swap ( Constraint & y )

inline

Swaps *this with y.

Definition at line 562 of file Constraint_inlines.hh.

References expr, kind_, swap(), Parma_Polyhedra_Library::swap(), and topology_.

Referenced by swap().

                                 {
   using std::swap;
   swap(expr, y.expr);
   swap(kind_, y.kind_);
   swap(topology_, y.topology_);
 }

void Parma_Polyhedra_Library::Constraint::mark_as_necessarily_closed ( )

inlineprivate

Marks the epsilon dimension as a standard dimension.

The row topology is changed to NOT_NECESSARILY_CLOSED, and the number of space dimensions is increased by 1.

Definition at line 98 of file Constraint_inlines.hh.

References is_not_necessarily_closed(), Parma_Polyhedra_Library::NECESSARILY_CLOSED, and topology_.

                                        {
   PPL_ASSERT(is_not_necessarily_closed());
   topology_ = NECESSARILY_CLOSED;
 }

void Parma_Polyhedra_Library::Constraint::mark_as_not_necessarily_closed ( )

inlineprivate

Marks the last dimension as the epsilon dimension.

The row topology is changed to NECESSARILY_CLOSED, and the number of space dimensions is decreased by 1.

Definition at line 104 of file Constraint_inlines.hh.

References is_necessarily_closed(), Parma_Polyhedra_Library::NOT_NECESSARILY_CLOSED, and topology_.

                                            {
   PPL_ASSERT(is_necessarily_closed());
   topology_ = NOT_NECESSARILY_CLOSED;
 }

dimension_type Parma_Polyhedra_Library::Constraint::max_space_dimension ( )

inlinestatic

Returns the maximum space dimension a Constraint can handle.

Definition at line 226 of file Constraint_inlines.hh.

References Parma_Polyhedra_Library::Linear_Expression::max_space_dimension().

Referenced by Parma_Polyhedra_Library::MIP_Problem::max_space_dimension(), and Parma_Polyhedra_Library::PIP_Problem::max_space_dimension().

                                 {
   return Linear_Expression::max_space_dimension();
 }

bool Parma_Polyhedra_Library::Constraint::OK ( ) const

Checks if all the invariants are satisfied.

Definition at line 467 of file Constraint.cc.

References strong_normalize().

Referenced by Parma_Polyhedra_Library::Constraint_System::affine_preimage(), Constraint(), construct_epsilon_geq_zero(), Parma_Polyhedra_Library::Polyhedron::drop_some_non_integer_points(), Parma_Polyhedra_Library::Polyhedron::expand_space_dimension(), operator>(), set_space_dimension(), and Parma_Polyhedra_Library::Polyhedron::topological_closure_assign().

                         {
   // Topology consistency checks.
   if (is_not_necessarily_closed() && expr.space_dimension() == 0) {
 #ifndef NDEBUG
     std::cerr << "Constraint has fewer coefficients than the minimum "
               << "allowed by its topology."
               << std::endl;
 #endif
     return false;
   }
 
   if (is_equality() && is_not_necessarily_closed()
       && epsilon_coefficient() != 0) {
 #ifndef NDEBUG
     std::cerr << "Illegal constraint: an equality cannot be strict."
               << std::endl;
 #endif
     return false;
   }
 
   // Normalization check.
   Constraint tmp = *this;
   tmp.strong_normalize();
   if (tmp != *this) {
 #ifndef NDEBUG
     std::cerr << "Constraint is not strongly normalized as it should be."
               << std::endl;
 #endif
     return false;
   }
 
   // All tests passed.
   return true;
 }

Constraint & Parma_Polyhedra_Library::Constraint::operator= ( const Constraint & c )

inline

Assignment operator.

Definition at line 208 of file Constraint_inlines.hh.

References c, and swap().

                                          {
   Constraint tmp = c;
   swap(*this, tmp);
 
   return *this;
 }

void Parma_Polyhedra_Library::Constraint::permute_space_dimensions ( const std::vector< Variable > & cycle )

Permutes the space dimensions of the constraint.

Definition at line 91 of file Constraint.cc.

                                                            {
   if (cycle.size() < 2) {
     // No-op. No need to call sign_normalize().
     return;
   }
 
   expr.permute_space_dimensions(cycle);
   // *this is still normalized but may be not strongly normalized:
   // sign normalization is necessary.
   sign_normalize();
   PPL_ASSERT(OK());
 }

void Parma_Polyhedra_Library::Constraint::print ( ) const

Prints *this to std::cerr using operator<<.

bool Parma_Polyhedra_Library::Constraint::remove_space_dimensions ( const Variables_Set & vars )

inline

Removes all the specified dimensions from the constraint.

The space dimension of the variable with the highest space dimension in vars must be at most the space dimension of this.

Always returns true. The return value is needed for compatibility with the Generator class.

Definition at line 260 of file Constraint_inlines.hh.

References expr, and Parma_Polyhedra_Library::Linear_Expression::remove_space_dimensions().

                                                              {
   expr.remove_space_dimensions(vars);
   return true;
 }

Representation Parma_Polyhedra_Library::Constraint::representation ( ) const

inline

Returns the current representation of *this.

Definition at line 216 of file Constraint_inlines.hh.

References expr, and Parma_Polyhedra_Library::Linear_Expression::representation().

                                  {
   return expr.representation();
 }

void Parma_Polyhedra_Library::Constraint::set_epsilon_coefficient ( Coefficient_traits::const_reference n )

inlineprivate

Sets the epsilon coefficient to n. The constraint must be NNC.

Definition at line 576 of file Constraint_inlines.hh.

References expr, is_not_necessarily_closed(), Parma_Polyhedra_Library::Linear_Expression::set_coefficient(), and Parma_Polyhedra_Library::Linear_Expression::space_dimension().

Referenced by construct_epsilon_geq_zero(), Parma_Polyhedra_Library::Polyhedron::drop_some_non_integer_points(), operator>(), and Parma_Polyhedra_Library::Polyhedron::topological_closure_assign().

                                                                        {
   PPL_ASSERT(is_not_necessarily_closed());
   expr.set_coefficient(Variable(expr.space_dimension() - 1), n);
 }

void Parma_Polyhedra_Library::Constraint::set_is_equality ( )

inlineprivate

Sets the constraint type to EQUALITY.

Definition at line 302 of file Constraint_inlines.hh.

References set_is_line_or_equality().

                             {
   set_is_line_or_equality();
 }

void Parma_Polyhedra_Library::Constraint::set_is_inequality ( )

inlineprivate

Sets the constraint to be an inequality.

Whether the constraint type will become NONSTRICT_INEQUALITY or STRICT_INEQUALITY depends on the topology and the value of the low-level coefficients of the constraint.

Definition at line 307 of file Constraint_inlines.hh.

References set_is_ray_or_point_or_inequality().

                               {
   set_is_ray_or_point_or_inequality();
 }

void Parma_Polyhedra_Library::Constraint::set_is_line_or_equality ( )

inlineprivate

Sets to LINE_OR_EQUALITY the kind of *this row.

Definition at line 72 of file Constraint_inlines.hh.

References kind_, and LINE_OR_EQUALITY.

Referenced by set_is_equality(), and Parma_Polyhedra_Library::Polyhedron::simplify_using_context_assign().

                                     {
   kind_ = LINE_OR_EQUALITY;
 }

void Parma_Polyhedra_Library::Constraint::set_is_ray_or_point_or_inequality ( )

inlineprivate

Sets to RAY_OR_POINT_OR_INEQUALITY the kind of *this row.

Definition at line 77 of file Constraint_inlines.hh.

References kind_, and RAY_OR_POINT_OR_INEQUALITY.

Referenced by set_is_inequality().

                                               {
   kind_ = RAY_OR_POINT_OR_INEQUALITY;
 }

void Parma_Polyhedra_Library::Constraint::set_necessarily_closed ( )

inlineprivate

Sets to NECESSARILY_CLOSED the topological kind of *this row.

Definition at line 110 of file Constraint_inlines.hh.

References Parma_Polyhedra_Library::NECESSARILY_CLOSED, and set_topology().

                                    {
   set_topology(NECESSARILY_CLOSED);
 }

void Parma_Polyhedra_Library::Constraint::set_not_necessarily_closed ( )

inlineprivate

Sets to NOT_NECESSARILY_CLOSED the topological kind of *this row.

Definition at line 115 of file Constraint_inlines.hh.

References Parma_Polyhedra_Library::NOT_NECESSARILY_CLOSED, and set_topology().

                                        {
   set_topology(NOT_NECESSARILY_CLOSED);
 }

void Parma_Polyhedra_Library::Constraint::set_representation ( Representation r )

inline

Converts *this to the specified representation.

Definition at line 221 of file Constraint_inlines.hh.

References expr, and Parma_Polyhedra_Library::Linear_Expression::set_representation().

                                                {
   expr.set_representation(r);
 }

void Parma_Polyhedra_Library::Constraint::set_space_dimension ( dimension_type space_dim )

inline

Sets the dimension of the vector space enclosing *this to space_dim .

Definition at line 254 of file Constraint_inlines.hh.

References OK(), and set_space_dimension_no_ok().

                                                         {
   set_space_dimension_no_ok(space_dim);
   PPL_ASSERT(OK());
 }

void Parma_Polyhedra_Library::Constraint::set_space_dimension_no_ok ( dimension_type space_dim )

inlineprivate

Sets the dimension of the vector space enclosing *this to space_dim . Sets the space dimension of the rows in the system to space_dim .

This method is for internal use, it does *not* assert OK() at the end, so it can be used for invalid objects.

Definition at line 231 of file Constraint_inlines.hh.

References expr, Parma_Polyhedra_Library::NECESSARILY_CLOSED, Parma_Polyhedra_Library::Linear_Expression::set_space_dimension(), space_dimension(), Parma_Polyhedra_Library::Linear_Expression::space_dimension(), strong_normalize(), Parma_Polyhedra_Library::Linear_Expression::swap_space_dimensions(), and topology().

Referenced by set_space_dimension().

                                                               {
   const dimension_type old_expr_space_dim = expr.space_dimension();
   if (topology() == NECESSARILY_CLOSED) {
     expr.set_space_dimension(space_dim);
   }
   else {
     const dimension_type old_space_dim = space_dimension();
     if (space_dim > old_space_dim) {
       expr.set_space_dimension(space_dim + 1);
       expr.swap_space_dimensions(Variable(space_dim), Variable(old_space_dim));
     }
     else {
       expr.swap_space_dimensions(Variable(space_dim), Variable(old_space_dim));
       expr.set_space_dimension(space_dim + 1);
     }
   }
   PPL_ASSERT(space_dimension() == space_dim);
   if (expr.space_dimension() < old_expr_space_dim) {
     strong_normalize();
   }
 }

void Parma_Polyhedra_Library::Constraint::set_topology ( Topology x )

inlineprivate

Sets to x the topological kind of *this row.

Definition at line 82 of file Constraint_inlines.hh.

References expr, Parma_Polyhedra_Library::NECESSARILY_CLOSED, Parma_Polyhedra_Library::Linear_Expression::set_space_dimension(), Parma_Polyhedra_Library::Linear_Expression::space_dimension(), topology(), and topology_.

Referenced by Parma_Polyhedra_Library::Constraint_System::insert(), Parma_Polyhedra_Library::Constraint_System::insert_pending(), set_necessarily_closed(), and set_not_necessarily_closed().

                                    {
   if (topology() == x) {
     return;
   }
   if (topology() == NECESSARILY_CLOSED) {
     // Add a column for the epsilon dimension.
     expr.set_space_dimension(expr.space_dimension() + 1);
   }
   else {
     PPL_ASSERT(expr.space_dimension() != 0);
     expr.set_space_dimension(expr.space_dimension() - 1);
   }
   topology_ = x;
 }

void Parma_Polyhedra_Library::Constraint::shift_space_dimensions	(	Variable	v,
		dimension_type	n
	)

inline

Shift by n positions the coefficients of variables, starting from the coefficient of v. This increases the space dimension by n.

Definition at line 52 of file Constraint_inlines.hh.

References expr, and Parma_Polyhedra_Library::Linear_Expression::shift_space_dimensions().

                                                                {
   expr.shift_space_dimensions(v, n);
 }

void Parma_Polyhedra_Library::Constraint::sign_normalize ( )

private

Normalizes the sign of the coefficients so that the first non-zero (homogeneous) coefficient of a line-or-equality is positive.

Definition at line 252 of file Constraint.cc.

Referenced by Parma_Polyhedra_Library::Polyhedron::simplify_using_context_assign(), and strong_normalize().

                               {
   if (is_line_or_equality()) {
     expr.sign_normalize();
   }
 }

dimension_type Parma_Polyhedra_Library::Constraint::space_dimension ( ) const

inline

Returns the dimension of the vector space enclosing *this.

Definition at line 47 of file Constraint_inlines.hh.

References expression(), and Parma_Polyhedra_Library::Expression_Hide_Last< T >::space_dimension().

                                   {
   return expression().space_dimension();
 }

void Parma_Polyhedra_Library::Constraint::strong_normalize ( )

inlineprivate

Strong normalization: ensures that different Constraint objects represent different hyperplanes or hyperspaces.

Applies both Constraint::normalize() and Constraint::sign_normalize().

Definition at line 335 of file Constraint_inlines.hh.

References expr, Parma_Polyhedra_Library::Linear_Expression::normalize(), and sign_normalize().

Referenced by Parma_Polyhedra_Library::Constraint_System::affine_preimage(), check_strong_normalized(), Constraint(), OK(), and set_space_dimension_no_ok().

                              {
   expr.normalize();
   sign_normalize();
 }

void Parma_Polyhedra_Library::Constraint::swap_space_dimensions	(	Variable	v1,
		Variable	v2
	)

Swaps the coefficients of the variables v1 and v2 .

Definition at line 80 of file Constraint.cc.

References Parma_Polyhedra_Library::Variable::space_dimension().

                                                              {
   PPL_ASSERT(v1.space_dimension() <= space_dimension());
   PPL_ASSERT(v2.space_dimension() <= space_dimension());
   expr.swap_space_dimensions(v1, v2);
   // *this is still normalized but it may not be strongly normalized.
   sign_normalize();
   PPL_ASSERT(OK());
 }

void Parma_Polyhedra_Library::Constraint::throw_dimension_incompatible	(	const char *	method,
		const char *	name_var,
		Variable	v
	)		const

private

Throws a std::invalid_argument exception containing the appropriate error message.

Definition at line 47 of file Constraint.cc.

References Parma_Polyhedra_Library::Variable::space_dimension().

Referenced by coefficient().

                                                                       {
   std::ostringstream s;
   s << "PPL::Constraint::" << method << ":" << std::endl
     << "this->space_dimension() == " << space_dimension() << ", "
     << name_var << ".space_dimension() == " << v.space_dimension() << ".";
   throw std::invalid_argument(s.str());
 }

void Parma_Polyhedra_Library::Constraint::throw_invalid_argument	(	const char *	method,
		const char *	message
	)		const

private

Throws a std::invalid_argument exception containing error message message.

Definition at line 38 of file Constraint.cc.

Referenced by Constraint().

                                                                    {
   std::ostringstream s;
   s << "PPL::Constraint::" << method << ":" << std::endl
     << message;
   throw std::invalid_argument(s.str());
 }

Topology Parma_Polyhedra_Library::Constraint::topology ( ) const

inlineprivate

Returns the topological kind of *this.

Definition at line 67 of file Constraint_inlines.hh.

References topology_.

Referenced by Parma_Polyhedra_Library::Constraint_System::insert(), Parma_Polyhedra_Library::Constraint_System::insert_pending(), is_equal_to(), set_space_dimension_no_ok(), and set_topology().

                            {
   return topology_;
 }

memory_size_type Parma_Polyhedra_Library::Constraint::total_memory_in_bytes ( ) const

inline

Returns a lower bound to the total size in bytes of the memory occupied by *this.

Definition at line 330 of file Constraint_inlines.hh.

References external_memory_in_bytes().

                                         {
   return sizeof(*this) + external_memory_in_bytes();
 }

Constraint::Type Parma_Polyhedra_Library::Constraint::type ( ) const

inline

Returns the constraint type of *this.

Definition at line 276 of file Constraint_inlines.hh.

References epsilon_coefficient(), EQUALITY, is_equality(), is_necessarily_closed(), NONSTRICT_INEQUALITY, and STRICT_INEQUALITY.

                        {
   if (is_equality()) {
     return EQUALITY;
   }
   if (is_necessarily_closed()) {
     return NONSTRICT_INEQUALITY;
   }
   if (epsilon_coefficient() < 0) {
     return STRICT_INEQUALITY;
   }
   else {
     return NONSTRICT_INEQUALITY;
   }
 }

const Constraint & Parma_Polyhedra_Library::Constraint::zero_dim_false ( )

inlinestatic

The unsatisfiable (zero-dimension space) constraint $0 = 1$ .

Definition at line 538 of file Constraint_inlines.hh.

References zero_dim_false_p.

Referenced by Parma_Polyhedra_Library::BD_Shape< T >::constraints(), Parma_Polyhedra_Library::Octagonal_Shape< T >::constraints(), Parma_Polyhedra_Library::Box< ITV >::constraints(), Parma_Polyhedra_Library::Constraint_System::initialize(), Parma_Polyhedra_Library::BD_Shape< T >::minimized_constraints(), and Parma_Polyhedra_Library::Box< ITV >::minimized_constraints().

                            {
   PPL_ASSERT(zero_dim_false_p != 0);
   return *zero_dim_false_p;
 }

const Constraint & Parma_Polyhedra_Library::Constraint::zero_dim_positivity ( )

inlinestatic

The true (zero-dimension space) constraint $0 \leq 1$ , also known as positivity constraint.

Definition at line 544 of file Constraint_inlines.hh.

References zero_dim_positivity_p.

Referenced by Parma_Polyhedra_Library::Constraint_System::add_low_level_constraints(), Parma_Polyhedra_Library::MIP_Problem::ascii_load(), Parma_Polyhedra_Library::PIP_Problem::ascii_load(), and Parma_Polyhedra_Library::Polyhedron::drop_some_non_integer_points().

                                 {
   PPL_ASSERT(zero_dim_positivity_p != 0);
   return *zero_dim_positivity_p;
 }

Friends And Related Function Documentation

int compare	(	const Constraint &	x,
		const Constraint &	y
	)

Returns: The returned absolute value can be , or .

Parameters

x	A row of coefficients;
y	Another row.

Compares x and y, where x and y may be of different size, in which case the "missing" coefficients are assumed to be zero. The comparison is such that:

equalities are smaller than inequalities;
lines are smaller than points and rays;
the ordering is lexicographic;
the positions compared are, in decreasing order of significance, 1, 2, ..., size(), 0;
the result is negative, zero, or positive if x is smaller than, equal to, or greater than y, respectively;
when x and y are different, the absolute value of the result is 1 if the difference is due to the coefficient in position 0; it is 2 otherwise.

When x and y represent the hyper-planes associated to two equality or inequality constraints, the coefficient at 0 is the known term. In this case, the return value can be characterized as follows:

-2, if x is smaller than y and they are not parallel;
-1, if x is smaller than y and they are parallel;
0, if x and y are equal;
+1, if y is smaller than x and they are parallel;
+2, if y is smaller than x and they are not parallel.

int compare	(	const Constraint &	x,
		const Constraint &	y
	)

References Parma_Polyhedra_Library::compare(), expr, and is_line_or_equality().

                                                      {
   const bool x_is_line_or_equality = x.is_line_or_equality();
   const bool y_is_line_or_equality = y.is_line_or_equality();
   if (x_is_line_or_equality != y_is_line_or_equality) {
     // Equalities (lines) precede inequalities (ray/point).
     return y_is_line_or_equality ? 2 : -2;
   }
 
   return compare(x.expr, y.expr);
 }

int compare	(	const Constraint &	x,
		const Constraint &	y
	)

friend

friend class Constraint_System

friend

Definition at line 735 of file Constraint_defs.hh.

friend class Grid

friend

Definition at line 740 of file Constraint_defs.hh.

friend class Linear_System< Constraint >

friend

Definition at line 734 of file Constraint_defs.hh.

template<typename T >

friend class Octagonal_Shape

friend

Definition at line 742 of file Constraint_defs.hh.

bool operator!=	(	const Constraint &	x,
		const Constraint &	y
	)

References is_equivalent_to().

                                                      {
   return !x.is_equivalent_to(y);
 }

bool operator!=	(	const Constraint &	x,
		const Constraint &	y
	)

Constraint operator<	(	const Linear_Expression &	e1,
		const Linear_Expression &	e2
	)

Constraint operator<	(	Variable	v1,
		Variable	v2
	)

Constraint operator<	(	const Linear_Expression &	e,
		Coefficient_traits::const_reference	n
	)

Constraint operator<	(	Coefficient_traits::const_reference	n,
		const Linear_Expression &	e
	)

Constraint operator<	(	const Linear_Expression &	e1,
		const Linear_Expression &	e2
	)

                                                                     {
   return e2 > e1;
 }

Constraint operator<	(	const Variable	v1,
		const Variable	v2
	)

                                                 {
   return v2 > v1;
 }

Constraint operator<	(	Coefficient_traits::const_reference	n,
		const Linear_Expression &	e
	)

                                                                            {
   return e > n;
 }

Constraint operator<	(	const Linear_Expression &	e,
		Coefficient_traits::const_reference	n
	)

                                                                            {
   return n > e;
 }

Constraint operator<	(	const Linear_Expression &	e1,
		const Linear_Expression &	e2
	)

friend

Constraint operator<	(	Variable	v1,
		Variable	v2
	)

friend

Constraint operator<	(	const Linear_Expression &	e,
		Coefficient_traits::const_reference	n
	)

friend

Constraint operator<	(	Coefficient_traits::const_reference	n,
		const Linear_Expression &	e
	)

friend

std::ostream & operator<<	(	std::ostream &	s,
		const Constraint &	c
	)

References Parma_Polyhedra_Library::Expression_Adapter< T >::begin(), Parma_Polyhedra_Library::Coefficient_zero(), Parma_Polyhedra_Library::Expression_Hide_Last< T >::end(), EQUALITY, expression(), inhomogeneous_term(), Parma_Polyhedra_Library::neg_assign(), NONSTRICT_INEQUALITY, PPL_DIRTY_TEMP_COEFFICIENT, STRICT_INEQUALITY, and type().

                                                               {
   PPL_DIRTY_TEMP_COEFFICIENT(cv);
   bool first = true;
   for (Constraint::expr_type::const_iterator i = c.expression().begin(),
          i_end = c.expression().end(); i != i_end; ++i) {
     cv = *i;
     if (!first) {
       if (cv > 0) {
         s << " + ";
       }
       else {
         s << " - ";
         neg_assign(cv);
       }
     }
     else {
       first = false;
     }
     if (cv == -1) {
       s << "-";
     }
     else if (cv != 1) {
       s << cv << "*";
     }
     s << i.variable();
   }
   if (first) {
     s << Coefficient_zero();
   }
   const char* relation_symbol = 0;
   switch (c.type()) {
   case Constraint::EQUALITY:
     relation_symbol = " = ";
     break;
   case Constraint::NONSTRICT_INEQUALITY:
     relation_symbol = " >= ";
     break;
   case Constraint::STRICT_INEQUALITY:
     relation_symbol = " > ";
     break;
   }
   s << relation_symbol << -c.inhomogeneous_term();
   return s;
 }

std::ostream & operator<<	(	std::ostream &	s,
		const Constraint::Type &	t
	)

References EQUALITY, NONSTRICT_INEQUALITY, and STRICT_INEQUALITY.

                                                                   {
   const char* n = 0;
   switch (t) {
   case Constraint::EQUALITY:
     n = "EQUALITY";
     break;
   case Constraint::NONSTRICT_INEQUALITY:
     n = "NONSTRICT_INEQUALITY";
     break;
   case Constraint::STRICT_INEQUALITY:
     n = "STRICT_INEQUALITY";
     break;
   }
   s << n;
   return s;
 }

std::ostream & operator<<	(	std::ostream &	s,
		const Constraint &	c
	)

std::ostream & operator<<	(	std::ostream &	s,
		const Constraint::Type &	t
	)

Constraint operator<=	(	const Linear_Expression &	e1,
		const Linear_Expression &	e2
	)

Constraint operator<=	(	Variable	v1,
		Variable	v2
	)

Constraint operator<=	(	const Linear_Expression &	e,
		Coefficient_traits::const_reference	n
	)

Constraint operator<=	(	Coefficient_traits::const_reference	n,
		const Linear_Expression &	e
	)

Constraint operator<=	(	const Linear_Expression &	e1,
		const Linear_Expression &	e2
	)

                                                                      {
   return e2 >= e1;
 }

Constraint operator<=	(	const Variable	v1,
		const Variable	v2
	)

                                                  {
   return v2 >= v1;
 }

Constraint operator<=	(	Coefficient_traits::const_reference	n,
		const Linear_Expression &	e
	)

                                                                             {
   return e >= n;
 }

Constraint operator<=	(	const Linear_Expression &	e,
		Coefficient_traits::const_reference	n
	)

                                                                             {
   return n >= e;
 }

Constraint operator<=	(	const Linear_Expression &	e1,
		const Linear_Expression &	e2
	)

friend

Constraint operator<=	(	Variable	v1,
		Variable	v2
	)

friend

Constraint operator<=	(	const Linear_Expression &	e,
		Coefficient_traits::const_reference	n
	)

friend

Constraint operator<=	(	Coefficient_traits::const_reference	n,
		const Linear_Expression &	e
	)

friend

Constraint operator==	(	const Linear_Expression &	e1,
		const Linear_Expression &	e2
	)

Constraint operator==	(	Variable	v1,
		Variable	v2
	)

Constraint operator==	(	const Linear_Expression &	e,
		Coefficient_traits::const_reference	n
	)

Constraint operator==	(	Coefficient_traits::const_reference	n,
		const Linear_Expression &	e
	)

bool operator==	(	const Constraint &	x,
		const Constraint &	y
	)

References is_equivalent_to().

                                                      {
   return x.is_equivalent_to(y);
 }

Constraint operator==	(	const Linear_Expression &	e1,
		const Linear_Expression &	e2
	)

References default_representation, EQUALITY, Parma_Polyhedra_Library::NECESSARILY_CLOSED, and Parma_Polyhedra_Library::Linear_Expression::space_dimension().

                                                                      {
   Linear_Expression diff(e1,
                          std::max(e1.space_dimension(), e2.space_dimension()),
                          Constraint::default_representation);
   diff -= e2;
   return Constraint(diff, Constraint::EQUALITY, NECESSARILY_CLOSED);
 }

Constraint operator==	(	Variable	v1,
		Variable	v2
	)

References default_representation, EQUALITY, Parma_Polyhedra_Library::NECESSARILY_CLOSED, Parma_Polyhedra_Library::Variable::space_dimension(), and Parma_Polyhedra_Library::swap().

                                      {
   if (v1.space_dimension() > v2.space_dimension()) {
     swap(v1, v2);
   }
   PPL_ASSERT(v1.space_dimension() <= v2.space_dimension());
 
   Linear_Expression diff(v1, Constraint::default_representation);
   diff -= v2;
   return Constraint(diff, Constraint::EQUALITY, NECESSARILY_CLOSED);
 }

Constraint operator==	(	Coefficient_traits::const_reference	n,
		const Linear_Expression &	e
	)

References default_representation, EQUALITY, Parma_Polyhedra_Library::NECESSARILY_CLOSED, and Parma_Polyhedra_Library::neg_assign().

                                                                             {
   Linear_Expression diff(e, Constraint::default_representation);
   neg_assign(diff);
   diff += n;
   return Constraint(diff, Constraint::EQUALITY, NECESSARILY_CLOSED);
 }

Constraint operator==	(	const Linear_Expression &	e,
		Coefficient_traits::const_reference	n
	)

References default_representation, EQUALITY, and Parma_Polyhedra_Library::NECESSARILY_CLOSED.

                                                                             {
   Linear_Expression diff(e, Constraint::default_representation);
   diff -= n;
   return Constraint(diff, Constraint::EQUALITY, NECESSARILY_CLOSED);
 }

Constraint operator==	(	const Linear_Expression &	e1,
		const Linear_Expression &	e2
	)

friend

Constraint operator==	(	Variable	v1,
		Variable	v2
	)

friend

Constraint operator==	(	const Linear_Expression &	e,
		Coefficient_traits::const_reference	n
	)

friend

Constraint operator==	(	Coefficient_traits::const_reference	n,
		const Linear_Expression &	e
	)

friend

bool operator==	(	const Constraint &	x,
		const Constraint &	y
	)

Constraint operator>	(	const Linear_Expression &	e1,
		const Linear_Expression &	e2
	)

Constraint operator>	(	Variable	v1,
		Variable	v2
	)

Constraint operator>	(	const Linear_Expression &	e,
		Coefficient_traits::const_reference	n
	)

Constraint operator>	(	Coefficient_traits::const_reference	n,
		const Linear_Expression &	e
	)

Constraint operator>	(	const Linear_Expression &	e1,
		const Linear_Expression &	e2
	)

References c, default_representation, Parma_Polyhedra_Library::NOT_NECESSARILY_CLOSED, OK(), set_epsilon_coefficient(), and STRICT_INEQUALITY.

                                                                     {
   Linear_Expression diff(e1, Constraint::default_representation);
   diff -= e2;
   Constraint c(diff, Constraint::STRICT_INEQUALITY, NOT_NECESSARILY_CLOSED);
 
   // NOTE: this also enforces normalization.
   c.set_epsilon_coefficient(-1);
   PPL_ASSERT(c.OK());
 
   return c;
 }

Constraint operator>	(	const Variable	v1,
		const Variable	v2
	)

References c, default_representation, Parma_Polyhedra_Library::NOT_NECESSARILY_CLOSED, OK(), set_epsilon_coefficient(), Parma_Polyhedra_Library::Linear_Expression::set_space_dimension(), Parma_Polyhedra_Library::Variable::space_dimension(), and STRICT_INEQUALITY.

                                                 {
   Linear_Expression diff(Constraint::default_representation);
   diff.set_space_dimension(std::max(v1.space_dimension(),
                                     v2.space_dimension()));
   diff += v1;
   diff -= v2;
   Constraint c(diff, Constraint::STRICT_INEQUALITY, NOT_NECESSARILY_CLOSED);
 
   c.set_epsilon_coefficient(-1);
   PPL_ASSERT(c.OK());
 
   return c;
 }

Constraint operator>	(	Coefficient_traits::const_reference	n,
		const Linear_Expression &	e
	)

References c, default_representation, Parma_Polyhedra_Library::neg_assign(), Parma_Polyhedra_Library::NOT_NECESSARILY_CLOSED, OK(), set_epsilon_coefficient(), and STRICT_INEQUALITY.

                                                                            {
   Linear_Expression diff(e, Constraint::default_representation);
   neg_assign(diff);
   diff += n;
   Constraint c(diff, Constraint::STRICT_INEQUALITY, NOT_NECESSARILY_CLOSED);
 
   // NOTE: this also enforces normalization.
   c.set_epsilon_coefficient(-1);
   PPL_ASSERT(c.OK());
 
   return c;
 }

Constraint operator>	(	const Linear_Expression &	e,
		Coefficient_traits::const_reference	n
	)

References c, default_representation, Parma_Polyhedra_Library::NOT_NECESSARILY_CLOSED, OK(), set_epsilon_coefficient(), and STRICT_INEQUALITY.

                                                                            {
   Linear_Expression diff(e, Constraint::default_representation);
   diff -= n;
   Constraint c(diff, Constraint::STRICT_INEQUALITY, NOT_NECESSARILY_CLOSED);
 
   // NOTE: this also enforces normalization.
   c.set_epsilon_coefficient(-1);
   PPL_ASSERT(c.OK());
 
   return c;
 }

Constraint operator>	(	const Linear_Expression &	e1,
		const Linear_Expression &	e2
	)

friend

Constraint operator>	(	Variable	v1,
		Variable	v2
	)

friend

Constraint operator>	(	const Linear_Expression &	e,
		Coefficient_traits::const_reference	n
	)

friend

Constraint operator>	(	Coefficient_traits::const_reference	n,
		const Linear_Expression &	e
	)

friend

Constraint operator>=	(	const Linear_Expression &	e1,
		const Linear_Expression &	e2
	)

Constraint operator>=	(	Variable	v1,
		Variable	v2
	)

Constraint operator>=	(	const Linear_Expression &	e,
		Coefficient_traits::const_reference	n
	)

Constraint operator>=	(	Coefficient_traits::const_reference	n,
		const Linear_Expression &	e
	)

Constraint operator>=	(	const Linear_Expression &	e1,
		const Linear_Expression &	e2
	)

References default_representation, Parma_Polyhedra_Library::NECESSARILY_CLOSED, NONSTRICT_INEQUALITY, and Parma_Polyhedra_Library::Linear_Expression::space_dimension().

                                                                      {
   Linear_Expression diff(e1,
                          std::max(e1.space_dimension(), e2.space_dimension()),
                          Constraint::default_representation);
   diff -= e2;
   return Constraint(diff, Constraint::NONSTRICT_INEQUALITY, NECESSARILY_CLOSED);
 }

Constraint operator>=	(	const Variable	v1,
		const Variable	v2
	)

References default_representation, Parma_Polyhedra_Library::NECESSARILY_CLOSED, NONSTRICT_INEQUALITY, Parma_Polyhedra_Library::Linear_Expression::set_space_dimension(), and Parma_Polyhedra_Library::Variable::space_dimension().

                                                  {
   Linear_Expression diff(Constraint::default_representation);
   diff.set_space_dimension(std::max(v1.space_dimension(),
                                     v2.space_dimension()));
   diff += v1;
   diff -= v2;
   return Constraint(diff, Constraint::NONSTRICT_INEQUALITY, NECESSARILY_CLOSED);
 }

Constraint operator>=	(	Coefficient_traits::const_reference	n,
		const Linear_Expression &	e
	)

References default_representation, Parma_Polyhedra_Library::NECESSARILY_CLOSED, Parma_Polyhedra_Library::neg_assign(), and NONSTRICT_INEQUALITY.

                                                                             {
   Linear_Expression diff(e, Constraint::default_representation);
   neg_assign(diff);
   diff += n;
   return Constraint(diff, Constraint::NONSTRICT_INEQUALITY, NECESSARILY_CLOSED);
 }

Constraint operator>=	(	const Linear_Expression &	e,
		Coefficient_traits::const_reference	n
	)

References default_representation, Parma_Polyhedra_Library::NECESSARILY_CLOSED, and NONSTRICT_INEQUALITY.

                                                                             {
   Linear_Expression diff(e, Constraint::default_representation);
   diff -= n;
   return Constraint(diff, Constraint::NONSTRICT_INEQUALITY, NECESSARILY_CLOSED);
 }

Constraint operator>=	(	const Linear_Expression &	e1,
		const Linear_Expression &	e2
	)

friend

Constraint operator>=	(	Variable	v1,
		Variable	v2
	)

friend

Constraint operator>=	(	const Linear_Expression &	e,
		Coefficient_traits::const_reference	n
	)

friend

Constraint operator>=	(	Coefficient_traits::const_reference	n,
		const Linear_Expression &	e
	)

friend

friend class Polyhedron

friend

Definition at line 736 of file Constraint_defs.hh.

friend class Scalar_Products

friend

Definition at line 737 of file Constraint_defs.hh.

void swap	(	Constraint &	x,
		Constraint &	y
	)

References m_swap().

                                    {
   x.m_swap(y);
 }

void swap	(	Constraint &	x,
		Constraint &	y
	)

friend class Termination_Helpers

friend

Definition at line 739 of file Constraint_defs.hh.

friend class Topology_Adjusted_Scalar_Product_Sign

friend

Definition at line 738 of file Constraint_defs.hh.

Member Data Documentation

const Representation Parma_Polyhedra_Library::Constraint::default_representation = SPARSE

static

The representation used for new Constraints.

Note: The copy constructor and the copy constructor with specified size use the representation of the original object, so that it is indistinguishable from the original object.

Definition at line 303 of file Constraint_defs.hh.

Referenced by operator==(), operator>(), and operator>=().

const PPL::Constraint * Parma_Polyhedra_Library::Constraint::epsilon_geq_zero_p = 0

staticprivate

Holds (between class initialization and finalization) a pointer to the zero-dimension space constraint $\epsilon \geq 0$ .

Definition at line 556 of file Constraint_defs.hh.

Referenced by epsilon_geq_zero().

const PPL::Constraint * Parma_Polyhedra_Library::Constraint::epsilon_leq_one_p = 0

staticprivate

Holds (between class initialization and finalization) a pointer to the zero-dimension space constraint $\epsilon \leq 1$ (used to implement NNC polyhedra).

Definition at line 563 of file Constraint_defs.hh.

Referenced by epsilon_leq_one().

Linear_Expression Parma_Polyhedra_Library::Constraint::expr

private

Definition at line 533 of file Constraint_defs.hh.

Kind Parma_Polyhedra_Library::Constraint::kind_

private

Definition at line 535 of file Constraint_defs.hh.

Referenced by Constraint(), is_equal_to(), is_line_or_equality(), is_ray_or_point_or_inequality(), m_swap(), set_is_line_or_equality(), and set_is_ray_or_point_or_inequality().

Topology Parma_Polyhedra_Library::Constraint::topology_

private

Definition at line 537 of file Constraint_defs.hh.

Referenced by is_necessarily_closed(), m_swap(), mark_as_necessarily_closed(), mark_as_not_necessarily_closed(), set_topology(), and topology().

const PPL::Constraint * Parma_Polyhedra_Library::Constraint::zero_dim_false_p = 0

staticprivate

Holds (between class initialization and finalization) a pointer to the unsatisfiable (zero-dimension space) constraint $0 = 1$ .

Definition at line 543 of file Constraint_defs.hh.

Referenced by zero_dim_false().

const PPL::Constraint * Parma_Polyhedra_Library::Constraint::zero_dim_positivity_p = 0

staticprivate

Holds (between class initialization and finalization) a pointer to the true (zero-dimension space) constraint $0 \leq 1$ , also known as positivity constraint.

Definition at line 550 of file Constraint_defs.hh.

Referenced by zero_dim_positivity().

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

Public Types

Public Member Functions

Static Public Member Functions

Static Public Attributes

Private Types

Private Member Functions

Static Private Member Functions

Private Attributes

Static Private Attributes

Friends

Related Functions

Detailed Description

Member Typedef Documentation

Constructor & Destructor Documentation

Member Function Documentation

Friends And Related Function Documentation

Member Data Documentation