A grid line, parameter or grid point. More...

#include <Grid_Generator_defs.hh>

Collaboration diagram for Parma_Polyhedra_Library::Grid_Generator:

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

enum	Type { LINE, PARAMETER, POINT }
	The generator type. More...

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

Public Member Functions
	Grid_Generator (Representation r=default_representation)
	Returns the origin of the zero-dimensional space $\Rset^0$ . More...

	Grid_Generator (const Grid_Generator &g)

	Grid_Generator (const Grid_Generator &g, Representation r)
	Copy constructor with specified representation. More...

	Grid_Generator (const Grid_Generator &g, dimension_type space_dim)

	Grid_Generator (const Grid_Generator &g, dimension_type space_dim, Representation r)
	Copy constructor with specified space dimension and representation. More...

	~Grid_Generator ()
	Destructor. More...

Grid_Generator &	operator= (const Grid_Generator &g)
	Assignment operator. More...

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

void	set_representation (Representation r)
	Converts *this to the specified representation. 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 grid generator. More...

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

void	shift_space_dimensions (Variable v, dimension_type n)

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

bool	is_line () const
	Returns `true` if and only if `*this` is a line. More...

bool	is_parameter () const
	Returns `true` if and only if `*this` is a parameter. More...

bool	is_line_or_parameter () const
	Returns `true` if and only if `*this` is a line or a parameter. More...

bool	is_point () const
	Returns `true` if and only if `*this` is a point. More...

bool	is_parameter_or_point () const
	Returns `true` if and only if `*this` row represents a parameter or a point. More...

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

Coefficient_traits::const_reference	divisor () const
	Returns the divisor 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_equivalent_to (const Grid_Generator &y) const
	Returns `true` if and only if `*this` and `y` are equivalent generators. More...

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

bool	all_homogeneous_terms_are_zero () const
	Returns `true` if and only if all the homogeneous terms of `*this` are . 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 (Grid_Generator &y)
	Swaps `*this` with `y`. More...

void	scale_to_divisor (Coefficient_traits::const_reference d)
	Scales `this` to be represented with a divisor of `d` (if \this is a parameter or point). Does nothing at all on lines. More...

void	set_divisor (Coefficient_traits::const_reference d)
	Sets the divisor of `*this` to `d`. More...

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

Static Public Member Functions
static Grid_Generator	grid_line (const Linear_Expression &e, Representation r=default_representation)
	Returns the line of direction `e`. More...

static Grid_Generator	parameter (const Linear_Expression &e=Linear_Expression::zero(), Coefficient_traits::const_reference d=Coefficient_one(), Representation r=default_representation)

static Grid_Generator	parameter (Representation r)
	Returns the parameter of direction and size `Linear_Expression::zero()` . More...

static Grid_Generator	parameter (const Linear_Expression &e, Representation r)
	Returns the parameter of direction and size `e` . More...

static Grid_Generator	grid_point (const Linear_Expression &e=Linear_Expression::zero(), Coefficient_traits::const_reference d=Coefficient_one(), Representation r=default_representation)
	Returns the point at `e` / `d`. More...

static Grid_Generator	grid_point (Representation r)
	Returns the point at `e` . More...

static Grid_Generator	grid_point (const Linear_Expression &e, Representation r)
	Returns the point at `e` . More...

static dimension_type	max_space_dimension ()
	Returns the maximum space dimension a Grid_Generator can handle. More...

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

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

static const Grid_Generator &	zero_dim_point ()
	Returns the origin of the zero-dimensional space $\Rset^0$ . More...

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

Private Member Functions
	Grid_Generator (dimension_type space_dim, Kind kind, Topology topology, Representation r=default_representation)

	Grid_Generator (Linear_Expression &e, Type t)
	Constructs a grid generator of type `t` from linear expression `e`, stealing the underlying data structures from `e`. More...

void	set_space_dimension_no_ok (dimension_type space_dim)

bool	is_equal_at_dimension (dimension_type dim, const Grid_Generator &gg) const
	Returns `true` if `*this` is equal to `gg` in dimension `dim`. More...

void	fancy_print (std::ostream &s) const
	A print function, with fancy, more human-friendly output. More...

void	set_is_parameter ()
	Converts the Grid_Generator into a parameter. More...

void	set_is_line ()
	Sets the Grid_Generator kind to `LINE_OR_EQUALITY`. More...

void	set_is_parameter_or_point ()
	Sets the Grid_Generator kind to `RAY_OR_POINT_OR_INEQUALITY`. 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 Grid_Generator objects represent different hyperplanes or hyperspaces. More...

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

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

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

void	throw_invalid_argument (const char method, const char reason) const
	Throw a `std::invalid_argument` exception containing the appropriate error message. 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...

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

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

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

Private Attributes
Linear_Expression	expr

Kind	kind_

Static Private Attributes
static const Grid_Generator *	zero_dim_point_p = 0
	Holds (between class initialization and finalization) a pointer to the origin of the zero-dimensional space $\Rset^0$ . More...

Friends
class	Expression_Adapter< Grid_Generator >

class	Grid_Generator_System

class	Grid

class	Linear_System< Grid_Generator >

class	Scalar_Products

class	Topology_Adjusted_Scalar_Product_Sign

std::ostream &	IO_Operators::operator<< (std::ostream &s, const Grid_Generator &g)

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

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

std::ostream &	operator<< (std::ostream &s, const Grid_Generator &g)

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

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

std::ostream &	operator<< (std::ostream &s, const Grid_Generator &g)
	Output operator. More...

void	swap (Grid_Generator &x, Grid_Generator &y)
	Swaps `x` with `y`. More...

Grid_Generator	grid_line (const Linear_Expression &e, Representation r=Grid_Generator::default_representation)
	Shorthand for Grid_Generator::grid_line(const Linear_Expression& e, Representation r). More...

Grid_Generator	parameter (const Linear_Expression &e=Linear_Expression::zero(), Coefficient_traits::const_reference d=Coefficient_one(), Representation r=Grid_Generator::default_representation)
	Shorthand for Grid_Generator::parameter(const Linear_Expression& e, Coefficient_traits::const_reference d, Representation r). More...

Grid_Generator	parameter (Representation r)
	Shorthand for Grid_Generator::parameter(Representation r). More...

Grid_Generator	parameter (const Linear_Expression &e, Representation r)
	Shorthand for Grid_Generator::parameter(const Linear_Expression& e, Representation r). More...

Grid_Generator	grid_point (const Linear_Expression &e=Linear_Expression::zero(), Coefficient_traits::const_reference d=Coefficient_one(), Representation r=Grid_Generator::default_representation)
	Shorthand for Grid_Generator::grid_point(const Linear_Expression& e, Coefficient_traits::const_reference d, Representation r). More...

Grid_Generator	grid_point (Representation r)
	Shorthand for Grid_Generator::grid_point(Representation r). More...

Grid_Generator	grid_point (const Linear_Expression &e, Representation r)
	Shorthand for Grid_Generator::grid_point(const Linear_Expression& e, Representation r). More...

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

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

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

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

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

Grid_Generator	grid_line (const Linear_Expression &e, Representation r)

Grid_Generator	parameter (const Linear_Expression &e, Coefficient_traits::const_reference d, Representation r)

Grid_Generator	parameter (Representation r)

Grid_Generator	parameter (const Linear_Expression &e, Representation r)

Grid_Generator	grid_point (const Linear_Expression &e, Coefficient_traits::const_reference d, Representation r)

Grid_Generator	grid_point (Representation r)

Grid_Generator	grid_point (const Linear_Expression &e, Representation r)

void	swap (Grid_Generator &x, Grid_Generator &y)

Detailed Description

A grid line, parameter or grid point.

An object of the class Grid_Generator is one of the following:

a grid_line $\vect{l} = (a_0, \ldots, a_{n-1})^\transpose$ ;
a parameter $\vect{q} = (\frac{a_0}{d}, \ldots, \frac{a_{n-1}}{d})^\transpose$ ;
a grid_point $\vect{p} = (\frac{a_0}{d}, \ldots, \frac{a_{n-1}}{d})^\transpose$ ;

where $n$ is the dimension of the space and, for grid_points and parameters, $d > 0$ is the divisor.

How to build a grid generator.: Each type of generator is built by applying the corresponding function (grid_line, parameter or grid_point) to a linear expression; the space dimension of the generator is defined as the space dimension of the corresponding linear expression. Linear expressions used to define a generator should be homogeneous (any constant term will be simply ignored). When defining grid points and parameters, an optional Coefficient argument can be used as a common divisor for all the coefficients occurring in the provided linear expression; the default value for this argument is 1.

: In all 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 a grid line with direction and having space dimension :
Grid_Generator l = grid_line(x - y - z);

By definition, the origin of the space is not a line, so that the following code throws an exception:
Grid_Generator l = grid_line(0*x);

Example 2: The following code builds the parameter as the vector $\vect{p} = (1, -1, -1)^\transpose \in \Rset^3$ which has the same direction as the line in Example 1:
Grid_Generator q = parameter(x - y - z);

Note that, unlike lines, for parameters, the length as well as the direction of the vector represented by the code is significant. Thus q is not the same as the parameter q1 defined by
Grid_Generator q1 = parameter(2x - 2y - 2z);

By definition, the origin of the space is not a parameter, so that the following code throws an exception:
Grid_Generator q = parameter(0*x);

Example 3: The following code builds the grid point $\vect{p} = (1, 0, 2)^\transpose \in \Rset^3$ :
Grid_Generator p = grid_point(1*x + 0*y + 2*z);

The same effect can be obtained by using the following code:
Grid_Generator p = grid_point(x + 2*z);

Similarly, the origin $\vect{0} \in \Rset^3$ can be defined using either one of the following lines of code:
Grid_Generator origin3 = grid_point(0*x + 0*y + 0*z);

Grid_Generator origin3_alt = grid_point(0*z);

Note however that the following code would have defined a different point, namely $\vect{0} \in \Rset^2$ :
Grid_Generator origin2 = grid_point(0*y);

The following two lines of code both define the only grid point having space dimension zero, namely $\vect{0} \in \Rset^0$ . In the second case we exploit the fact that the first argument of the function point is optional.
Grid_Generator origin0 = Generator::zero_dim_point();

Grid_Generator origin0_alt = grid_point();

Example 4: The grid point $\vect{p}$ specified in Example 3 above can also be obtained with the following code, where we provide a non-default value for the second argument of the function grid_point (the divisor):
Grid_Generator p = grid_point(2*x + 0*y + 4*z, 2);

Obviously, the divisor can be used to specify points having some non-integer (but rational) coordinates. For instance, the grid point $\vect{p1} = (-1.5, 3.2, 2.1)^\transpose \in \Rset^3$ can be specified by the following code:
Grid_Generator p1 = grid_point(-15*x + 32*y + 21*z, 10);

If a zero divisor is provided, an exception is thrown.

Example 5: Parameters, like grid points can have a divisor. For instance, the parameter $\vect{q} = (1, 0, 2)^\transpose \in \Rset^3$ can be defined:
Grid_Generator q = parameter(2*x + 0*y + 4*z, 2);

Also, the divisor can be used to specify parameters having some non-integer (but rational) coordinates. For instance, the parameter $\vect{q} = (-1.5, 3.2, 2.1)^\transpose \in \Rset^3$ can be defined:
Grid_Generator q = parameter(-15*x + 32*y + 21*z, 10);

If a zero divisor is provided, an exception is thrown.

How to inspect a grid generator: Several methods are provided to examine a grid generator and extract all the encoded information: its space dimension, its type and the value of its integer coefficients and the value of the denominator.

Example 6: The following code shows how it is possible to access each single coefficient of a grid generator. If g1 is a grid point having coordinates $(a_0, \ldots, a_{n-1})^\transpose$ , we construct the parameter g2 having coordinates $(a_0, 2 a_1, \ldots, (i+1)a_i, \ldots, n a_{n-1})^\transpose$ .
if (g1.is_point()) {

cout << "Grid point g1: " << g1 << endl;

Linear_Expression e;

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

e += (i + 1) * g1.coefficient(Variable(i)) * Variable(i);

Grid_Generator g2 = parameter(e, g1.divisor());

cout << "Parameter g2: " << g2 << endl;

}

else

cout << "Grid generator g1 is not a grid point." << endl;

Therefore, for the grid point
Grid_Generator g1 = grid_point(2*x - y + 3*z, 2);

we would obtain the following output:
Grid point g1: p((2*A - B + 3*C)/2)

Parameter g2: parameter((2*A - 2*B + 9*C)/2)

When working with grid points and parameters, be careful not to confuse the notion of coefficient with the notion of coordinate: these are equivalent only when the divisor is 1.

Definition at line 271 of file Grid_Generator_defs.hh.

Member Typedef Documentation

typedef Expression_Hide_Last<Expression_Hide_Inhomo<Linear_Expression> > Parma_Polyhedra_Library::Grid_Generator::expr_type

The type of the (adapted) internal expression.

Definition at line 535 of file Grid_Generator_defs.hh.

Constructor & Destructor Documentation

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

inlineexplicit

Returns the origin of the zero-dimensional space $\Rset^0$ .

Definition at line 93 of file Grid_Generator_inlines.hh.

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

   : expr(Coefficient_one(), r),
     kind_(RAY_OR_POINT_OR_INEQUALITY) {
   expr.set_space_dimension(1);
   PPL_ASSERT(OK());
 }

Parma_Polyhedra_Library::Grid_Generator::Grid_Generator ( const Grid_Generator & g )

inline

Ordinary copy constructor. The new Grid_Generator will have the same representation as g.

Definition at line 101 of file Grid_Generator_inlines.hh.

   : expr(g.expr),
     kind_(g.kind_) {
 }

Parma_Polyhedra_Library::Grid_Generator::Grid_Generator	(	const Grid_Generator &	g,
		Representation	r
	)

inline

Copy constructor with specified representation.

Definition at line 107 of file Grid_Generator_inlines.hh.

   : expr(g.expr, r),
     kind_(g.kind_) {
 }

Parma_Polyhedra_Library::Grid_Generator::Grid_Generator	(	const Grid_Generator &	g,
		dimension_type	space_dim
	)

inline

Copy constructor with specified space dimension. The new Grid_Generator will have the same representation as g.

Definition at line 124 of file Grid_Generator_inlines.hh.

References OK(), and space_dimension().

   : expr(g.expr, space_dim + 1),
     kind_(g.kind_) {
   PPL_ASSERT(OK());
   PPL_ASSERT(space_dimension() == space_dim);
 }

Parma_Polyhedra_Library::Grid_Generator::Grid_Generator	(	const Grid_Generator &	g,
		dimension_type	space_dim,
		Representation	r
	)

inline

Copy constructor with specified space dimension and representation.

Definition at line 133 of file Grid_Generator_inlines.hh.

References OK(), and space_dimension().

   : expr(g.expr, space_dim + 1, r),
     kind_(g.kind_) {
   PPL_ASSERT(OK());
   PPL_ASSERT(space_dimension() == space_dim);
 }

Parma_Polyhedra_Library::Grid_Generator::~Grid_Generator ( )

inline

Destructor.

Definition at line 142 of file Grid_Generator_inlines.hh.

142 {

143 }

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

inlineprivate

Constructs a Grid_Generator with the specified space dimension, kind and topology.

Definition at line 113 of file Grid_Generator_inlines.hh.

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

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

Parma_Polyhedra_Library::Grid_Generator::Grid_Generator	(	Linear_Expression &	e,
		Type	t
	)

inlineprivate

Constructs a grid generator of type t from linear expression e, stealing the underlying data structures from e.

The last column in e becomes the parameter divisor column of the new Grid_Generator.

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

Definition at line 81 of file Grid_Generator_inlines.hh.

References expr, kind_, LINE, LINE_OR_EQUALITY, OK(), RAY_OR_POINT_OR_INEQUALITY, and swap().

                                                               {
   swap(expr, e);
   if (type == LINE) {
     kind_ = LINE_OR_EQUALITY;
   }
   else {
     kind_ = RAY_OR_POINT_OR_INEQUALITY;
   }
   PPL_ASSERT(OK());
 }

Member Function Documentation

bool Parma_Polyhedra_Library::Grid_Generator::all_homogeneous_terms_are_zero ( ) const

Returns true if and only if all the homogeneous terms of *this are $0$ .

Definition at line 296 of file Grid_Generator.cc.

Referenced by Parma_Polyhedra_Library::Grid_Generator_System::insert(), and Parma_Polyhedra_Library::Grid_Generator_System::remove_invalid_lines_and_parameters().

                                                         {
   // This does not check neither the first nor the last coefficient.
   return expr.all_zeroes(1, expr.space_dimension());
 }

void Parma_Polyhedra_Library::Grid_Generator::ascii_dump ( ) const

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

Referenced by Parma_Polyhedra_Library::Grid::OK().

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

Writes to s an ASCII representation of *this.

Definition at line 186 of file Grid_Generator.cc.

                                                  {
   expr.ascii_dump(s);
   s << ' ';
   switch (type()) {
   case LINE:
     s << "L";
     break;
   case PARAMETER:
     s << "Q";
     break;
   case POINT:
     s << "P";
     break;
   }
   s << "\n";
 }

bool Parma_Polyhedra_Library::Grid_Generator::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 206 of file Grid_Generator.cc.

                                            {
 
   if (!expr.ascii_load(s)) {
     return false;
   }
 
   std::string str;
 
   if (!(s >> str)) {
     return false;
   }
   if (str == "L") {
     set_is_line();
   }
   else if (str == "P" || str == "Q") {
     set_is_parameter_or_point();
   }
   else {
     return false;
   }
 
   PPL_ASSERT(OK());
   return true;
 }

bool Parma_Polyhedra_Library::Grid_Generator::check_strong_normalized ( ) const

private

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

Definition at line 326 of file Grid_Generator.cc.

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

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

Coefficient_traits::const_reference Parma_Polyhedra_Library::Grid_Generator::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 277 of file Grid_Generator_inlines.hh.

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

Referenced by Parma_Polyhedra_Library::Grid::constrains(), and Parma_Polyhedra_Library::Grid::wrap_assign().

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

Coefficient_traits::const_reference Parma_Polyhedra_Library::Grid_Generator::divisor ( ) const

inline

Returns the divisor of *this.

Exceptions

std::invalid_argument Thrown if *this is a line.

Definition at line 239 of file Grid_Generator_inlines.hh.

References Parma_Polyhedra_Library::Linear_Expression::coefficient(), expr, Parma_Polyhedra_Library::Linear_Expression::inhomogeneous_term(), is_line(), is_line_or_parameter(), space_dimension(), and throw_invalid_argument().

                               {
   if (is_line()) {
     throw_invalid_argument("divisor()", "*this is a line");
   }
   if (is_line_or_parameter()) {
     return expr.coefficient(Variable(space_dimension()));
   }
   else {
     return expr.inhomogeneous_term();
   }
 }

Grid_Generator::expr_type Parma_Polyhedra_Library::Grid_Generator::expression ( ) const

inline

Partial read access to the (adapted) internal expression.

Definition at line 146 of file Grid_Generator_inlines.hh.

References expr.

Referenced by Parma_Polyhedra_Library::Grid::constrains(), Parma_Polyhedra_Library::Grid::map_space_dimensions(), Parma_Polyhedra_Library::Grid::max_min(), Parma_Polyhedra_Library::Grid::select_wider_generators(), and space_dimension().

                                  {
   return expr_type(expr, true);
 }

memory_size_type Parma_Polyhedra_Library::Grid_Generator::external_memory_in_bytes ( ) const

inline

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

Definition at line 290 of file Grid_Generator_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::Grid_Generator::fancy_print ( std::ostream & s ) const

private

A print function, with fancy, more human-friendly output.

This is used by operator<<().

Definition at line 348 of file Grid_Generator.cc.

References c, LINE, Parma_Polyhedra_Library::neg_assign(), Parma_Polyhedra_Library::IO_Operators::operator<<(), PARAMETER, POINT, and PPL_DIRTY_TEMP_COEFFICIENT.

Referenced by operator<<().

                                                   {
   bool need_divisor = false;
   bool extra_parentheses = false;
   const dimension_type num_variables = space_dimension();
   const Grid_Generator::Type t = type();
   switch (t) {
   case Grid_Generator::LINE:
     s << "l(";
     break;
   case Grid_Generator::PARAMETER:
     s << "q(";
     if (expr.coefficient(Variable(num_variables)) == 1) {
       break;
     }
     goto any_point;
   case Grid_Generator::POINT:
     s << "p(";
     if (expr.inhomogeneous_term() > 1) {
     any_point:
       need_divisor = true;
       if (!expr.all_zeroes(1, num_variables + 1)) {
         extra_parentheses = true;
         s << "(";
         break;
       }
     }
     break;
   }
 
   PPL_DIRTY_TEMP_COEFFICIENT(c);
   bool first = true;
   for (Linear_Expression::const_iterator i = expr.begin(),
          i_end = expr.lower_bound(Variable(num_variables)); i != i_end; ++i) {
     c = *i;
     if (!first) {
       if (c > 0) {
         s << " + ";
       }
       else {
         s << " - ";
         neg_assign(c);
       }
     }
     else {
       first = false;
     }
     if (c == -1) {
       s << "-";
     }
     else if (c != 1) {
       s << c << "*";
     }
     IO_Operators::operator<<(s, i.variable());
   }
   if (first) {
     // A grid generator in the origin.
     s << 0;
   }
   if (extra_parentheses) {
     s << ")";
   }
   if (need_divisor) {
     s << "/" << divisor();
   }
   s << ")";
 }

void Parma_Polyhedra_Library::Grid_Generator::finalize ( )

static

Finalizes the class.

Definition at line 341 of file Grid_Generator.cc.

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

                             {
   PPL_ASSERT(zero_dim_point_p != 0);
   delete zero_dim_point_p;
   zero_dim_point_p = 0;
 }

PPL::Grid_Generator Parma_Polyhedra_Library::Grid_Generator::grid_line	(	const Linear_Expression &	e,
		Representation	r = `default_representation`
	)

static

Returns the line of direction e.

Exceptions

std::invalid_argument Thrown if the homogeneous part of e represents the origin of the vector space.

Definition at line 124 of file Grid_Generator.cc.

References Parma_Polyhedra_Library::Linear_Expression::all_homogeneous_terms_are_zero(), Parma_Polyhedra_Library::Coefficient_zero(), Parma_Polyhedra_Library::Linear_Expression::set_inhomogeneous_term(), Parma_Polyhedra_Library::Linear_Expression::space_dimension(), and strong_normalize().

Referenced by grid_line().

                                                                          {
   // The origin of the space cannot be a line.
   if (e.all_homogeneous_terms_are_zero()) {
     throw std::invalid_argument("PPL::grid_line(e):\n"
                                 "e == 0, but the origin cannot be a line.");
   }
 
   // Add 1 to space dimension to allow for parameter divisor column.
   Linear_Expression ec(e, 1 + e.space_dimension(), r);
   ec.set_inhomogeneous_term(Coefficient_zero());
   // Using this constructor saves reallocation when creating the
   // coefficients.
   Grid_Generator gg(ec, LINE);
 
   // Enforce normalization.
   gg.strong_normalize();
   return gg;
 }

PPL::Grid_Generator Parma_Polyhedra_Library::Grid_Generator::grid_point	(	const Linear_Expression &	e = `Linear_Expression::zero()`,
		Coefficient_traits::const_reference	d = `Coefficient_one()`,
		Representation	r = `default_representation`
	)

static

Returns the point at e / d.

Both e and d are optional arguments, with default values Linear_Expression::zero() and Coefficient_one(), respectively.

Exceptions

std::invalid_argument Thrown if d is zero.

Definition at line 86 of file Grid_Generator.cc.

References expr, Parma_Polyhedra_Library::neg_assign(), Parma_Polyhedra_Library::Linear_Expression::normalize(), Parma_Polyhedra_Library::Linear_Expression::set_inhomogeneous_term(), and Parma_Polyhedra_Library::Linear_Expression::space_dimension().

Referenced by grid_point().

                                                   {
   if (d == 0) {
     throw std::invalid_argument("PPL::grid_point(e, d):\n"
                                 "d == 0.");
   }
   // Add 1 to space dimension to allow for parameter divisor column.
   Linear_Expression ec(e, 1 + e.space_dimension(), r);
   ec.set_inhomogeneous_term(d);
 
   // If the divisor is negative, negate it and all the coefficients of
   // the point, so as to satisfy the invariant.
   if (d < 0) {
     neg_assign(ec);
   }
 
   // Using this constructor saves reallocation when creating the
   // coefficients.
   Grid_Generator gg(ec, POINT);
 
   // Enforce normalization.
   gg.expr.normalize();
   return gg;
 }

PPL::Grid_Generator Parma_Polyhedra_Library::Grid_Generator::grid_point ( Representation r )

static

Returns the point at e .

Definition at line 113 of file Grid_Generator.cc.

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

                                               {
   return grid_point(Linear_Expression::zero(), Coefficient_one(), r);
 }

PPL::Grid_Generator Parma_Polyhedra_Library::Grid_Generator::grid_point	(	const Linear_Expression &	e,
		Representation	r
	)

static

Returns the point at e .

Definition at line 118 of file Grid_Generator.cc.

References Parma_Polyhedra_Library::Coefficient_one().

                                                   {
   return grid_point(e, Coefficient_one(), r);
 }

void Parma_Polyhedra_Library::Grid_Generator::initialize ( )

static

Initializes the class.

Definition at line 335 of file Grid_Generator.cc.

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

                               {
   PPL_ASSERT(zero_dim_point_p == 0);
   zero_dim_point_p = new Grid_Generator(grid_point());
 }

bool Parma_Polyhedra_Library::Grid_Generator::is_equal_at_dimension	(	dimension_type	dim,
		const Grid_Generator &	gg
	)		const

inlineprivate

Returns true if *this is equal to gg in dimension dim.

Definition at line 252 of file Grid_Generator_inlines.hh.

References divisor(), expr, and Parma_Polyhedra_Library::Linear_Expression::get().

Referenced by Parma_Polyhedra_Library::Grid::select_wider_generators().

                                                                      {
   const Grid_Generator& x = *this;
   return x.expr.get(dim) * y.divisor() == y.expr.get(dim) * x.divisor();
 }

bool Parma_Polyhedra_Library::Grid_Generator::is_equal_to ( const Grid_Generator & 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 generators.

Definition at line 291 of file Grid_Generator.cc.

References expr, and kind_.

Referenced by is_equivalent_to(), and Parma_Polyhedra_Library::Grid::OK().

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

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

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

Generators having different space dimensions are not equivalent.

Definition at line 264 of file Grid_Generator.cc.

References Parma_Polyhedra_Library::Coefficient_zero(), expr, is_equal_to(), Parma_Polyhedra_Library::Linear_Expression::normalize(), Parma_Polyhedra_Library::Linear_Expression::set(), space_dimension(), and type().

Referenced by operator==().

                                                                  {
   const Grid_Generator& 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()) {
     return false;
   }
 
   Grid_Generator tmp_x = *this;
   Grid_Generator tmp_y = y;
   const Variable last_var(x_space_dim);
   if (x_type == POINT || x_type == LINE) {
     tmp_x.expr.set(last_var, Coefficient_zero());
     tmp_y.expr.set(last_var, Coefficient_zero());
   }
   // Normalize the copies, including the divisor column.
   tmp_x.expr.normalize();
   tmp_y.expr.normalize();
   // Check for equality.
   return tmp_x.is_equal_to(tmp_y);
 }

bool Parma_Polyhedra_Library::Grid_Generator::is_line ( ) const

inline

Returns true if and only if *this is a line.

Definition at line 203 of file Grid_Generator_inlines.hh.

References is_line_or_equality().

Referenced by Parma_Polyhedra_Library::Grid::constrains(), divisor(), Parma_Polyhedra_Library::Grid::frequency_no_check(), Parma_Polyhedra_Library::Grid::multiply_grid(), Parma_Polyhedra_Library::Congruence_System::satisfies_all_congruences(), set_divisor(), Parma_Polyhedra_Library::Grid::simplify(), and type().

                               {
   return is_line_or_equality();
 }

bool Parma_Polyhedra_Library::Grid_Generator::is_line_or_equality ( ) const

inlineprivate

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

Definition at line 40 of file Grid_Generator_inlines.hh.

References kind_, and LINE_OR_EQUALITY.

Referenced by compare(), and is_line().

                                           {
   return (kind_ == LINE_OR_EQUALITY);
 }

bool Parma_Polyhedra_Library::Grid_Generator::is_line_or_parameter ( ) const

inline

Returns true if and only if *this is a line or a parameter.

Definition at line 213 of file Grid_Generator_inlines.hh.

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

Referenced by Parma_Polyhedra_Library::Grid::add_grid_generator(), Parma_Polyhedra_Library::Grid::bounds_no_check(), divisor(), Parma_Polyhedra_Library::Grid::is_bounded(), is_parameter(), is_point(), Parma_Polyhedra_Library::Grid_Generator_System::remove_invalid_lines_and_parameters(), and set_divisor().

                                            {
   return expr.inhomogeneous_term() == 0;
 }

bool Parma_Polyhedra_Library::Grid_Generator::is_necessarily_closed ( ) const

inlineprivate

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

Definition at line 30 of file Grid_Generator_inlines.hh.

Referenced by OK().

                                             {
   return true;
 }

bool Parma_Polyhedra_Library::Grid_Generator::is_not_necessarily_closed ( ) const

inlineprivate

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

Definition at line 35 of file Grid_Generator_inlines.hh.

                                                 {
   return false;
 }

bool Parma_Polyhedra_Library::Grid_Generator::is_parameter ( ) const

inline

Returns true if and only if *this is a parameter.

Definition at line 208 of file Grid_Generator_inlines.hh.

References is_line_or_parameter(), and is_parameter_or_point().

Referenced by Parma_Polyhedra_Library::Grid::add_grid_generator(), Parma_Polyhedra_Library::Grid::frequency_no_check(), Parma_Polyhedra_Library::Grid_Generator_System::insert(), Parma_Polyhedra_Library::Grid::simplify_using_context_assign(), and strong_normalize().

                                    {
   return is_parameter_or_point() && is_line_or_parameter();
 }

bool Parma_Polyhedra_Library::Grid_Generator::is_parameter_or_point ( ) const

inline

Returns true if and only if *this row represents a parameter or a point.

Definition at line 223 of file Grid_Generator_inlines.hh.

References is_ray_or_point_or_inequality().

Referenced by Parma_Polyhedra_Library::Grid::add_grid_generator(), is_parameter(), Parma_Polyhedra_Library::Grid::multiply_grid(), Parma_Polyhedra_Library::Grid::normalize_divisors(), Parma_Polyhedra_Library::Grid::reduce_parameter_with_line(), and Parma_Polyhedra_Library::Grid::simplify().

                                             {
   return is_ray_or_point_or_inequality();
 }

bool Parma_Polyhedra_Library::Grid_Generator::is_point ( ) const

inline

Returns true if and only if *this is a point.

Definition at line 218 of file Grid_Generator_inlines.hh.

References is_line_or_parameter().

Referenced by Parma_Polyhedra_Library::Grid::frequency_no_check(), Parma_Polyhedra_Library::Grid::map_space_dimensions(), Parma_Polyhedra_Library::Grid::simplify_using_context_assign(), Parma_Polyhedra_Library::Grid::time_elapse_assign(), and type().

                                {
   return !is_line_or_parameter();
 }

bool Parma_Polyhedra_Library::Grid_Generator::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 45 of file Grid_Generator_inlines.hh.

References kind_, and RAY_OR_POINT_OR_INEQUALITY.

Referenced by is_parameter_or_point().

                                                     {
   return (kind_ == RAY_OR_POINT_OR_INEQUALITY);
 }

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

private

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

Parameters

y	The Grid_Generator 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 Grid_Generator to *this and normalizes it.

Definition at line 244 of file Grid_Generator.cc.

References expr.

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

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

inline

Swaps *this with y.

Definition at line 308 of file Grid_Generator_inlines.hh.

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

Referenced by swap().

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

dimension_type Parma_Polyhedra_Library::Grid_Generator::max_space_dimension ( )

inlinestatic

Returns the maximum space dimension a Grid_Generator can handle.

Definition at line 161 of file Grid_Generator_inlines.hh.

References Parma_Polyhedra_Library::Linear_Expression::max_space_dimension().

                                     {
   return Linear_Expression::max_space_dimension() - 1;
 }

bool Parma_Polyhedra_Library::Grid_Generator::OK ( ) const

Checks if all the invariants are satisfied.

Definition at line 443 of file Grid_Generator.cc.

References Parma_Polyhedra_Library::Linear_Expression::coefficient(), divisor(), expr, Parma_Polyhedra_Library::Linear_Expression::inhomogeneous_term(), is_necessarily_closed(), LINE, PARAMETER, POINT, Parma_Polyhedra_Library::Linear_Expression::space_dimension(), and type().

Referenced by Parma_Polyhedra_Library::Grid_Generator_System::add_universe_rows_and_columns(), Parma_Polyhedra_Library::Grid_Generator_System::affine_image(), Parma_Polyhedra_Library::Grid::Grid(), Grid_Generator(), Parma_Polyhedra_Library::Grid::reduce_line_with_line(), and Parma_Polyhedra_Library::Grid::relation_with().

                             {
   // NOTE: do not check for normalization, as it does not hold.
   const Grid_Generator& x = *this;
 
   if (!x.is_necessarily_closed()) {
 #ifndef NDEBUG
     std::cerr << "Grid_Generator should be necessarily closed.\n";
 #endif
     return false;
   }
 
   if (x.expr.space_dimension() < 1) {
 #ifndef NDEBUG
     std::cerr << "Grid_Generator has fewer coefficients than the minimum "
               << "allowed:\nspace dimension is " << x.expr.space_dimension()
               << ", minimum is 1.\n";
 #endif
     return false;
   }
 
   switch (x.type()) {
   case Grid_Generator::LINE:
     if (x.expr.inhomogeneous_term() != 0) {
 #ifndef NDEBUG
       std::cerr << "Inhomogeneous terms of lines must be zero!\n";
 #endif
       return false;
     }
     break;
 
   case Grid_Generator::PARAMETER:
     if (x.expr.inhomogeneous_term() != 0) {
 #ifndef NDEBUG
       std::cerr << "Inhomogeneous terms of parameters must be zero!\n";
 #endif
       return false;
     }
     if (x.divisor() <= 0) {
 #ifndef NDEBUG
       std::cerr << "Parameters must have positive divisors!\n";
 #endif
       return false;
     }
     break;
 
   case Grid_Generator::POINT:
     if (x.expr.inhomogeneous_term() <= 0) {
 #ifndef NDEBUG
       std::cerr << "Points must have positive divisors!\n";
 #endif
       return false;
     }
     if (x.expr.coefficient(Variable(space_dimension())) != 0) {
 #ifndef NDEBUG
       std::cerr << "Points must have a zero parameter divisor!\n";
 #endif
       return false;
     }
     break;
 
   } // switch (x.type())
 
   // All tests passed.
   return true;
 }

Grid_Generator & Parma_Polyhedra_Library::Grid_Generator::operator= ( const Grid_Generator & g )

inline

Assignment operator.

Definition at line 269 of file Grid_Generator_inlines.hh.

References swap().

                                                  {
   Grid_Generator tmp = g;
   swap(*this, tmp);
 
   return *this;
 }

PPL::Grid_Generator Parma_Polyhedra_Library::Grid_Generator::parameter	(	const Linear_Expression &	e = `Linear_Expression::zero()`,
		Coefficient_traits::const_reference	d = `Coefficient_one()`,
		Representation	r = `default_representation`
	)

static

Returns the parameter of direction e and size e/d, with the same representation as e.

Both e and d are optional arguments, with default values Linear_Expression::zero() and Coefficient_one(), respectively.

Exceptions

std::invalid_argument Thrown if d is zero.

Definition at line 56 of file Grid_Generator.cc.

References Parma_Polyhedra_Library::Coefficient_zero(), Parma_Polyhedra_Library::neg_assign(), Parma_Polyhedra_Library::Linear_Expression::set_inhomogeneous_term(), and Parma_Polyhedra_Library::Linear_Expression::space_dimension().

Referenced by parameter().

                                                  {
   if (d == 0) {
     throw std::invalid_argument("PPL::parameter(e, d):\n"
                                 "d == 0.");
   }
   // Add 1 to space dimension to allow for parameter divisor column.
   Linear_Expression ec(e, e.space_dimension() + 1, r);
 
   ec.set_inhomogeneous_term(Coefficient_zero());
   const Variable divisor_var(e.space_dimension());
   ec.set(divisor_var, d);
 
   // If the divisor is negative, negate it and all the coefficients of
   // the parameter, so as to satisfy the invariant.
   if (d < 0) {
     neg_assign(ec);
   }
 
   // Using this constructor saves reallocation when creating the
   // coefficients.
   const Grid_Generator gg(ec, PARAMETER);
 
   // NOTE: normalize() must *not* be called here, because this is a parameter,
   // and it would change the represented parameter.
   return gg;
 }

static Grid_Generator Parma_Polyhedra_Library::Grid_Generator::parameter ( Representation r )

static

Returns the parameter of direction and size Linear_Expression::zero() .

static Grid_Generator Parma_Polyhedra_Library::Grid_Generator::parameter	(	const Linear_Expression &	e,
		Representation	r
	)

static

Returns the parameter of direction and size e .

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

Permutes the space dimensions of the grid generator.

Definition at line 167 of file Grid_Generator.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-normalizing a parameter changes its meaning, so do nothing for
   // parameters.
   if (!is_parameter()) {
     sign_normalize();
   }
   PPL_ASSERT(OK());
 }

void Parma_Polyhedra_Library::Grid_Generator::print ( ) const

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

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

Removes all the specified dimensions from the grid generator.

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 156 of file Grid_Generator.cc.

References Parma_Polyhedra_Library::Variables_Set::space_dimension().

                                                                     {
   PPL_ASSERT(vars.space_dimension() <= space_dimension());
 
   expr.remove_space_dimensions(vars);
 
   PPL_ASSERT(OK());
   return true;
 }

Representation Parma_Polyhedra_Library::Grid_Generator::representation ( ) const

inline

Returns the current representation of *this.

Definition at line 151 of file Grid_Generator_inlines.hh.

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

                                      {
   return expr.representation();
 }

void Parma_Polyhedra_Library::Grid_Generator::scale_to_divisor ( Coefficient_traits::const_reference d )

Scales *this to be represented with a divisor of d (if \*this is a parameter or point). Does nothing at all on lines.

It is assumed that d is a multiple of the current divisor and different from zero. The behavior is undefined if the assumption does not hold.

Definition at line 302 of file Grid_Generator.cc.

References Parma_Polyhedra_Library::exact_div_assign(), and PPL_DIRTY_TEMP_COEFFICIENT.

Referenced by Parma_Polyhedra_Library::Grid::Grid().

                                                                        {
   PPL_ASSERT(d != 0);
   if (is_line()) {
     return;
   }
 
   PPL_DIRTY_TEMP_COEFFICIENT(factor);
   exact_div_assign(factor, d, divisor());
   set_divisor(d);
   PPL_ASSERT(factor > 0);
   if (factor > 1) {
     // Don't scale the first and last coefficients.
     expr.mul_assign(factor, 1, expr.space_dimension());
   }
 }

void Parma_Polyhedra_Library::Grid_Generator::set_divisor ( Coefficient_traits::const_reference d )

inline

Sets the divisor of *this to d.

Exceptions

std::invalid_argument Thrown if *this is a line.

Definition at line 228 of file Grid_Generator_inlines.hh.

References expr, is_line(), is_line_or_parameter(), Parma_Polyhedra_Library::Linear_Expression::set_coefficient(), Parma_Polyhedra_Library::Linear_Expression::set_inhomogeneous_term(), and space_dimension().

                                                                {
   PPL_ASSERT(!is_line());
   if (is_line_or_parameter()) {
     expr.set_coefficient(Variable(space_dimension()), d);
   }
   else {
     expr.set_inhomogeneous_term(d);
   }
 }

void Parma_Polyhedra_Library::Grid_Generator::set_is_line ( )

inlineprivate

Sets the Grid_Generator kind to LINE_OR_EQUALITY.

Definition at line 259 of file Grid_Generator_inlines.hh.

References set_is_line_or_equality().

                             {
   set_is_line_or_equality();
 }

void Parma_Polyhedra_Library::Grid_Generator::set_is_line_or_equality ( )

inlineprivate

Sets to LINE_OR_EQUALITY the kind of *this row.

Definition at line 55 of file Grid_Generator_inlines.hh.

References kind_, and LINE_OR_EQUALITY.

Referenced by set_is_line().

                                         {
   kind_ = LINE_OR_EQUALITY;
 }

void Parma_Polyhedra_Library::Grid_Generator::set_is_parameter ( )

private

Converts the Grid_Generator into a parameter.

Definition at line 232 of file Grid_Generator.cc.

References Parma_Polyhedra_Library::Coefficient_zero().

Referenced by Parma_Polyhedra_Library::Grid::relation_with(), and Parma_Polyhedra_Library::Grid::time_elapse_assign().

                                     {
   if (is_line()) {
     set_is_parameter_or_point();
   }
   else if (!is_line_or_parameter()) {
     // The grid generator is a point.
     expr.set(Variable(expr.space_dimension() - 1), expr.inhomogeneous_term());
     expr.set_inhomogeneous_term(Coefficient_zero());
   }
 }

void Parma_Polyhedra_Library::Grid_Generator::set_is_parameter_or_point ( )

inlineprivate

Sets the Grid_Generator kind to RAY_OR_POINT_OR_INEQUALITY.

Definition at line 264 of file Grid_Generator_inlines.hh.

References set_is_ray_or_point_or_inequality().

                                           {
   set_is_ray_or_point_or_inequality();
 }

void Parma_Polyhedra_Library::Grid_Generator::set_is_ray_or_point_or_inequality ( )

inlineprivate

Sets to RAY_OR_POINT_OR_INEQUALITY the kind of *this row.

Definition at line 60 of file Grid_Generator_inlines.hh.

References kind_, and RAY_OR_POINT_OR_INEQUALITY.

Referenced by set_is_parameter_or_point().

                                                   {
   kind_ = RAY_OR_POINT_OR_INEQUALITY;
 }

void Parma_Polyhedra_Library::Grid_Generator::set_necessarily_closed ( )

inlineprivate

Sets to NECESSARILY_CLOSED the topological kind of *this row.

Definition at line 71 of file Grid_Generator_inlines.hh.

References Parma_Polyhedra_Library::NECESSARILY_CLOSED, and set_topology().

                                        {
   set_topology(NECESSARILY_CLOSED);
 }

void Parma_Polyhedra_Library::Grid_Generator::set_not_necessarily_closed ( )

inlineprivate

Sets to NOT_NECESSARILY_CLOSED the topological kind of *this row.

Definition at line 76 of file Grid_Generator_inlines.hh.

References Parma_Polyhedra_Library::NOT_NECESSARILY_CLOSED, and set_topology().

                                            {
   set_topology(NOT_NECESSARILY_CLOSED);
 }

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

inline

Converts *this to the specified representation.

Definition at line 156 of file Grid_Generator_inlines.hh.

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

                                                    {
   expr.set_representation(r);
 }

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

inline

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

Definition at line 171 of file Grid_Generator_inlines.hh.

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

Referenced by set_space_dimension_no_ok().

                                                             {
   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);
 }

void Parma_Polyhedra_Library::Grid_Generator::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 185 of file Grid_Generator_inlines.hh.

References set_space_dimension().

                                                                   {
   set_space_dimension(space_dim);
 }

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

inlineprivate

Sets to x the topological kind of *this row.

Definition at line 65 of file Grid_Generator_inlines.hh.

References Parma_Polyhedra_Library::NECESSARILY_CLOSED, and PPL_USED.

Referenced by Parma_Polyhedra_Library::Grid::conversion(), set_necessarily_closed(), and set_not_necessarily_closed().

                                        {
   PPL_USED(x);
   PPL_ASSERT(x == NECESSARILY_CLOSED);
 }

void Parma_Polyhedra_Library::Grid_Generator::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 190 of file Grid_Generator_inlines.hh.

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

                                                                    {
   expr.shift_space_dimensions(v, n);
 }

void Parma_Polyhedra_Library::Grid_Generator::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 319 of file Grid_Generator.cc.

Referenced by strong_normalize().

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

dimension_type Parma_Polyhedra_Library::Grid_Generator::space_dimension ( ) const

inline

Returns the dimension of the vector space enclosing *this.

Definition at line 166 of file Grid_Generator_inlines.hh.

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

                                       {
   return expression().space_dimension();
 }

void Parma_Polyhedra_Library::Grid_Generator::strong_normalize ( )

inlineprivate

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

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

Definition at line 301 of file Grid_Generator_inlines.hh.

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

Referenced by check_strong_normalized(), grid_line(), and Parma_Polyhedra_Library::Grid::relation_with().

                                  {
   PPL_ASSERT(!is_parameter());
   expr.normalize();
   sign_normalize();
 }

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

Swaps the coefficients of the variables v1 and v2 .

Definition at line 144 of file Grid_Generator.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.
   if (!is_parameter()) {
     sign_normalize();
   }
   PPL_ASSERT(OK());
 }

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

private

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

Definition at line 36 of file Grid_Generator.cc.

References Parma_Polyhedra_Library::Variable::space_dimension(), and space_dimension().

Referenced by coefficient().

                                                                           {
   std::ostringstream s;
   s << "PPL::Grid_Generator::" << 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::Grid_Generator::throw_invalid_argument	(	const char *	method,
		const char *	reason
	)		const

private

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

Definition at line 47 of file Grid_Generator.cc.

Referenced by divisor().

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

Topology Parma_Polyhedra_Library::Grid_Generator::topology ( ) const

inlineprivate

Returns the topological kind of *this.

Definition at line 50 of file Grid_Generator_inlines.hh.

References Parma_Polyhedra_Library::NECESSARILY_CLOSED.

                                {
   return NECESSARILY_CLOSED;
 }

memory_size_type Parma_Polyhedra_Library::Grid_Generator::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 285 of file Grid_Generator_inlines.hh.

References external_memory_in_bytes().

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

Grid_Generator::Type Parma_Polyhedra_Library::Grid_Generator::type ( ) const

inline

Returns the generator type of *this.

Definition at line 195 of file Grid_Generator_inlines.hh.

References is_line(), is_point(), LINE, PARAMETER, and POINT.

Referenced by is_equivalent_to(), Parma_Polyhedra_Library::Grid::map_space_dimensions(), OK(), and Parma_Polyhedra_Library::Grid::relation_with().

                            {
   if (is_line()) {
     return LINE;
   }
   return is_point() ? POINT : PARAMETER;
 }

const Grid_Generator & Parma_Polyhedra_Library::Grid_Generator::zero_dim_point ( )

inlinestatic

Returns the origin of the zero-dimensional space $\Rset^0$ .

Definition at line 295 of file Grid_Generator_inlines.hh.

References zero_dim_point_p.

Referenced by Parma_Polyhedra_Library::Grid_Generator_System::initialize().

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

Friends And Related Function Documentation

int compare	(	const Grid_Generator &	x,
		const Grid_Generator &	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 Grid_Generator &	x,
		const Grid_Generator &	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 Grid_Generator &	x,
		const Grid_Generator &	y
	)

friend

friend class Expression_Adapter< Grid_Generator >

friend

Definition at line 704 of file Grid_Generator_defs.hh.

friend class Grid

friend

Definition at line 706 of file Grid_Generator_defs.hh.

friend class Grid_Generator_System

friend

Definition at line 705 of file Grid_Generator_defs.hh.

Grid_Generator grid_line	(	const Linear_Expression &	e,
		Representation	r
	)

References grid_line().

                                                         {
   return Grid_Generator::grid_line(e, r);
 }

Grid_Generator grid_line	(	const Linear_Expression &	e,
		Representation	r = `Grid_Generator::default_representation`
	)

Grid_Generator grid_point	(	const Linear_Expression &	e,
		Coefficient_traits::const_reference	d,
		Representation	r
	)

References grid_point().

                                                                   {
   return Grid_Generator::grid_point(e, d, r);
 }

Grid_Generator grid_point ( Representation r )

References grid_point().

                              {
   return Grid_Generator::grid_point(r);
 }

Grid_Generator grid_point	(	const Linear_Expression &	e,
		Representation	r
	)

References grid_point().

                                                          {
   return Grid_Generator::grid_point(e, r);
 }

Grid_Generator grid_point	(	const Linear_Expression &	e = `Linear_Expression::zero()`,
		Coefficient_traits::const_reference	d = `Coefficient_one()`,
		Representation	r = `Grid_Generator::default_representation`
	)

Grid_Generator grid_point ( Representation r )

Grid_Generator grid_point	(	const Linear_Expression &	e,
		Representation	r
	)

std::ostream& IO_Operators::operator<<	(	std::ostream &	s,
		const Grid_Generator &	g
	)

friend

friend class Linear_System< Grid_Generator >

friend

Definition at line 707 of file Grid_Generator_defs.hh.

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

                                                              {
   return !(x == y);
 }

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

std::ostream & operator<<	(	std::ostream &	s,
		const Grid_Generator &	g
	)

std::ostream & operator<<	(	std::ostream &	s,
		const Grid_Generator &	g
	)

References fancy_print().

                                                                   {
   g.fancy_print(s);
   return s;
 }

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

References LINE, PARAMETER, and POINT.

                                                            {
   const char* n = 0;
   switch (t) {
   case Grid_Generator::LINE:
     n = "LINE";
     break;
   case Grid_Generator::PARAMETER:
     n = "PARAMETER";
     break;
   case Grid_Generator::POINT:
     n = "POINT";
     break;
   }
   s << n;
   return s;
 }

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

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

References is_equivalent_to().

                                                              {
   return x.is_equivalent_to(y);
 }

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

Grid_Generator parameter	(	const Linear_Expression &	e,
		Coefficient_traits::const_reference	d,
		Representation	r
	)

References parameter().

                                                                  {
   return Grid_Generator::parameter(e, d, r);
 }

Grid_Generator parameter ( Representation r )

References parameter().

                             {
   return Grid_Generator::parameter(r);
 }

Grid_Generator parameter	(	const Linear_Expression &	e,
		Representation	r
	)

References parameter().

                                                         {
   return Grid_Generator::parameter(e, r);
 }

Grid_Generator parameter	(	const Linear_Expression &	e = `Linear_Expression::zero()`,
		Coefficient_traits::const_reference	d = `Coefficient_one()`,
		Representation	r = `Grid_Generator::default_representation`
	)

Grid_Generator parameter ( Representation r )

Grid_Generator parameter	(	const Linear_Expression &	e,
		Representation	r
	)

friend class Scalar_Products

friend

Definition at line 708 of file Grid_Generator_defs.hh.

void swap	(	Grid_Generator &	x,
		Grid_Generator &	y
	)

Referenced by Grid_Generator(), m_swap(), and operator=().

void swap	(	Grid_Generator &	x,
		Grid_Generator &	y
	)

References m_swap().

                                            {
   x.m_swap(y);
 }

friend class Topology_Adjusted_Scalar_Product_Sign

friend

Definition at line 709 of file Grid_Generator_defs.hh.

Member Data Documentation

const Representation Parma_Polyhedra_Library::Grid_Generator::default_representation = SPARSE

static

The representation used for new Grid_Generators.

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 286 of file Grid_Generator_defs.hh.

Linear_Expression Parma_Polyhedra_Library::Grid_Generator::expr

private

Definition at line 540 of file Grid_Generator_defs.hh.

Kind Parma_Polyhedra_Library::Grid_Generator::kind_

private

Definition at line 542 of file Grid_Generator_defs.hh.

Referenced by Grid_Generator(), 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().

const PPL::Grid_Generator * Parma_Polyhedra_Library::Grid_Generator::zero_dim_point_p = 0

staticprivate

Holds (between class initialization and finalization) a pointer to the origin of the zero-dimensional space $\Rset^0$ .

Definition at line 548 of file Grid_Generator_defs.hh.

Referenced by zero_dim_point().

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

Public Types

Public Member Functions

Static Public Member Functions

Static Public Attributes

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