Parma_Polyhedra_Library::Linear_Row Class Reference
[C++ Language Interface]

The base class for linear expressions, constraints and generators. More...

#include <Linear_Row.defs.hh>

Inheritance diagram for Parma_Polyhedra_Library::Linear_Row:
Inheritance graph
[legend]
Collaboration diagram for Parma_Polyhedra_Library::Linear_Row:
Collaboration graph
[legend]

List of all members.

Classes

class  Flags
 The type of the object to which the coefficients refer to, encoding both topology and kind. More...

Public Types

enum  Kind { LINE_OR_EQUALITY = 0, RAY_OR_POINT_OR_INEQUALITY = 1 }
 

The possible kinds of Linear_Row objects.

More...

Public Member Functions

 Linear_Row ()
 Pre-constructs a row: construction must be completed by construct().
 Linear_Row (dimension_type sz, Flags f)
 Tight constructor: resizing will require reallocation.
 Linear_Row (dimension_type sz, dimension_type capacity, Flags f)
 Sizing constructor with capacity.
 Linear_Row (const Linear_Row &y)
 Ordinary copy constructor.
 Linear_Row (const Linear_Row &y, dimension_type capacity)
 Copy constructor with specified capacity.
 Linear_Row (const Linear_Row &y, dimension_type sz, dimension_type capacity)
 Copy constructor with specified size and capacity.
 ~Linear_Row ()
 Destructor.
dimension_type space_dimension () const
 Returns the dimension of the vector space enclosing *this.
Coefficient_traits::const_reference inhomogeneous_term () const
 Returns the inhomogeneous term.
Coefficient_traits::const_reference coefficient (dimension_type n) const
 Returns the coefficient $a_n$.
void sign_normalize ()
 Normalizes the sign of the coefficients so that the first non-zero (homogeneous) coefficient of a line-or-equality is positive.
void strong_normalize ()
 Strong normalization: ensures that different Linear_Row objects represent different hyperplanes or hyperspaces.
bool check_strong_normalized () const
 Returns true if and only if the coefficients are strongly normalized.
void linear_combine (const Linear_Row &y, dimension_type k)
 Linearly combines *this with y so that *this[k] is 0.
bool is_zero () const
 Returns true if and only if all the terms of *this are $0$.
bool all_homogeneous_terms_are_zero () const
 Returns true if and only if all the homogeneous terms of *this are $0$.
void ascii_dump () const
 Writes to std::cerr an ASCII representation of *this.
void ascii_dump (std::ostream &s) const
 Writes to s an ASCII representation of *this.
void print () const
 Prints *this to std::cerr using operator<<.
bool ascii_load (std::istream &s)
 Loads from s an ASCII representation (as produced by ascii_dump(std::ostream&) const) and sets *this accordingly. Returns true if successful, false otherwise.
bool OK () const
 Checks if all the invariants are satisfied.
bool OK (dimension_type row_size, dimension_type row_capacity) const
 Checks if all the invariants are satisfied and that the actual size and capacity match the values provided as arguments.
Post-constructors

void construct (dimension_type sz, Flags f)
 Constructs properly a default-constructed element.
void construct (dimension_type sz, dimension_type capacity, Flags f)
 Constructs properly a default-constructed element.
Flags inspection methods

const Flagsflags () const
 Returns a const reference to the flags of *this.
Flagsflags ()
 Returns a non-const reference to the flags of *this.
Topology topology () const
 Returns the topological kind of *this.
bool is_not_necessarily_closed () const
 Returns true if and only if the topology of *this row is not necessarily closed.
bool is_necessarily_closed () const
 Returns true if and only if the topology of *this row is necessarily closed.
bool is_line_or_equality () const
 Returns true if and only if *this row represents a line or an equality.
bool is_ray_or_point_or_inequality () const
 Returns true if and only if *this row represents a ray, a point or an inequality.
Flags coercion methods

void set_necessarily_closed ()
 Sets to NECESSARILY_CLOSED the topological kind of *this row.
void set_not_necessarily_closed ()
 Sets to NOT_NECESSARILY_CLOSED the topological kind of *this row.
void set_is_line_or_equality ()
 Sets to LINE_OR_EQUALITY the kind of *this row.
void set_is_ray_or_point_or_inequality ()
 Sets to RAY_OR_POINT_OR_INEQUALITY the kind of *this row.

Static Public Member Functions

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

Friends

class Parma_Polyhedra_Library::Linear_Expression
class Parma_Polyhedra_Library::Constraint
class Parma_Polyhedra_Library::Generator

Related Functions

(Note that these are not member functions.)



bool operator== (const Linear_Row &x, const Linear_Row &y)
 Returns true if and only if x and y are equal.
bool operator!= (const Linear_Row &x, const Linear_Row &y)
 Returns true if and only if x and y are different.
int compare (const Linear_Row &x, const Linear_Row &y)
 The basic comparison function.
void swap (Parma_Polyhedra_Library::Linear_Row &x, Parma_Polyhedra_Library::Linear_Row &y)
 Specializes std::swap.
void iter_swap (std::vector< Parma_Polyhedra_Library::Linear_Row >::iterator x, std::vector< Parma_Polyhedra_Library::Linear_Row >::iterator y)
 Specializes std::iter_swap.

Detailed Description

The base class for linear expressions, constraints and generators.

The class Linear_Row allows us to build objects of the form $[b, a_0, \ldots, a_{d-1}]_{(t, k)}$, i.e., a finite sequence of coefficients subscripted by a pair of flags, which are both stored in a Linear_Row::Flags object. The flag $t \in \{ \mathrm{c}, \mathrm{nnc} \}$ represents the topology and the flag $k \in \{\mathord{=}, \mathord{\geq} \}$ represents the kind of the Linear_Row object. Note that, even though all the four possible combinations of topology and kind values will result in a legal Linear_Row::Flags object, some of these pose additional constraints on the values of the Linear_Row's coefficients.

When $t = c$, we have the following cases ($d$ is the dimension of the vector space):

When $t = \mathrm{nnc}$, the last coefficient of the Linear_Row is associated to the slack variable $\epsilon$, so that we have the following cases ($d$ is again the dimension of the vector space, but this time we have $d+2$ coefficients):

So, a Linear_Row can be both a constraint and a generator: it can be an equality, a strict or non-strict inequality, a line, a ray, a point or a closure point.

The inhomogeneous term of a constraint can be zero or different from zero.

Points and closure points must have a positive inhomogeneous term (which is used as a common divisor for all the other coefficients), lines and rays must have the inhomogeneous term equal to zero. If needed, the coefficients of points and closure points are negated at creation time so that they satisfy this invariant. The invariant is maintained because, when combining a point or closure point with another generator, we only consider positive combinations.

The $\epsilon$ coefficient, when present, is negative for strict inequality constraints, positive for points and equal to zero in all the other cases. Note that the above description corresponds to the end-user, high-level view of a Linear_Row object. In the implementation, to allow for code reuse, it is sometimes useful to regard an $\mathrm{nnc}$-object on the vector space $\Rset^d$ as if it was a $\mathrm{c}$-object on the vector space $\Rset^{d+1}$, therefore interpreting the slack variable $\epsilon$ as an ordinary dimension of the vector space.

A Linear_Row object implementing a Linear_Expression is always of the form $[0, a_0, \ldots, a_{d-1}]_{(c,=)}$, which represents the linear expression $\sum_{i=0}^{d-1} a_i x_i$.

Definition at line 125 of file Linear_Row.defs.hh.


Member Enumeration Documentation

The possible kinds of Linear_Row objects.

Enumerator:
LINE_OR_EQUALITY 
RAY_OR_POINT_OR_INEQUALITY 

Definition at line 128 of file Linear_Row.defs.hh.

00128             {
00129     LINE_OR_EQUALITY = 0,
00130     RAY_OR_POINT_OR_INEQUALITY = 1
00131   };


Constructor & Destructor Documentation

Parma_Polyhedra_Library::Linear_Row::Linear_Row (  )  [inline]

Pre-constructs a row: construction must be completed by construct().

Definition at line 159 of file Linear_Row.inlines.hh.

00160   : Row() {
00161 }

Parma_Polyhedra_Library::Linear_Row::Linear_Row ( dimension_type  sz,
Flags  f 
) [inline]

Tight constructor: resizing will require reallocation.

Definition at line 181 of file Linear_Row.inlines.hh.

References construct().

00181                                                              {
00182   construct(sz, f);
00183 }

Parma_Polyhedra_Library::Linear_Row::Linear_Row ( dimension_type  sz,
dimension_type  capacity,
Flags  f 
) [inline]

Sizing constructor with capacity.

Definition at line 170 of file Linear_Row.inlines.hh.

References construct().

00171                                       {
00172   construct(sz, capacity, f);
00173 }

Parma_Polyhedra_Library::Linear_Row::Linear_Row ( const Linear_Row y  )  [inline]

Ordinary copy constructor.

Definition at line 186 of file Linear_Row.inlines.hh.

00187   : Row(y) {
00188 }

Parma_Polyhedra_Library::Linear_Row::Linear_Row ( const Linear_Row y,
dimension_type  capacity 
) [inline]

Copy constructor with specified capacity.

It is assumed that capacity is greater than or equal to y size.

Definition at line 191 of file Linear_Row.inlines.hh.

00193   : Row(y, capacity) {
00194 }

Parma_Polyhedra_Library::Linear_Row::Linear_Row ( const Linear_Row y,
dimension_type  sz,
dimension_type  capacity 
) [inline]

Copy constructor with specified size and capacity.

It is assumed that sz is greater than or equal to the size of y and, of course, that sz is less than or equal to capacity.

Definition at line 197 of file Linear_Row.inlines.hh.

00199   : Row(y, sz, capacity) {
00200 }

Parma_Polyhedra_Library::Linear_Row::~Linear_Row (  )  [inline]

Destructor.

Definition at line 203 of file Linear_Row.inlines.hh.

00203                         {
00204 }


Member Function Documentation

bool Parma_Polyhedra_Library::Linear_Row::all_homogeneous_terms_are_zero (  )  const
void Parma_Polyhedra_Library::Linear_Row::ascii_dump ( std::ostream &  s  )  const

Writes to s an ASCII representation of *this.

Reimplemented from Parma_Polyhedra_Library::Row.

Reimplemented in Parma_Polyhedra_Library::Linear_Expression, Parma_Polyhedra_Library::Constraint, Parma_Polyhedra_Library::Generator, Parma_Polyhedra_Library::Grid_Generator, and Parma_Polyhedra_Library::PIP_Tree_Node::Artificial_Parameter.

Definition at line 190 of file Linear_Row.cc.

References Parma_Polyhedra_Library::Linear_Row::Flags::ascii_dump(), flags(), and Parma_Polyhedra_Library::Row::size().

00190                                              {
00191   const Row& x = *this;
00192   const dimension_type x_size = x.size();
00193   s << "size " << x_size << " ";
00194   for (dimension_type i = 0; i < x_size; ++i)
00195     s << x[i] << ' ';
00196   s << "f ";
00197   flags().ascii_dump(s);
00198   s << "\n";
00199 }

void Parma_Polyhedra_Library::Linear_Row::ascii_dump (  )  const
bool Parma_Polyhedra_Library::Linear_Row::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.

Reimplemented from Parma_Polyhedra_Library::Row.

Reimplemented in Parma_Polyhedra_Library::Linear_Expression, Parma_Polyhedra_Library::Constraint, Parma_Polyhedra_Library::Generator, Parma_Polyhedra_Library::Grid_Generator, and Parma_Polyhedra_Library::PIP_Tree_Node::Artificial_Parameter.

Definition at line 204 of file Linear_Row.cc.

References Parma_Polyhedra_Library::Row::shrink(), Parma_Polyhedra_Library::Row::size(), and Parma_Polyhedra_Library::Row::swap().

00204                                        {
00205   std::string str;
00206   if (!(s >> str) || str != "size")
00207     return false;
00208   dimension_type new_size;
00209   if (!(s >> new_size))
00210     return false;
00211 
00212   Row& x = *this;
00213   const dimension_type old_size = x.size();
00214   if (new_size < old_size)
00215     x.shrink(new_size);
00216   else if (new_size > old_size) {
00217     Row y(new_size, Row::Flags());
00218     x.swap(y);
00219   }
00220 
00221   for (dimension_type col = 0; col < new_size; ++col)
00222     if (!(s >> x[col]))
00223       return false;
00224   if (!(s >> str) || str != "f")
00225     return false;
00226   return flags().ascii_load(s);
00227 }

bool Parma_Polyhedra_Library::Linear_Row::check_strong_normalized (  )  const

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

Definition at line 58 of file Linear_Row.cc.

References compare(), and strong_normalize().

Referenced by Parma_Polyhedra_Library::Linear_System::add_pending_row(), Parma_Polyhedra_Library::Linear_System::add_row(), Parma_Polyhedra_Library::Linear_System::insert(), and Parma_Polyhedra_Library::Linear_System::insert_pending().

00058                                              {
00059   Linear_Row tmp = *this;
00060   tmp.strong_normalize();
00061   return compare(*this, tmp) == 0;
00062 }

Coefficient_traits::const_reference Parma_Polyhedra_Library::Linear_Row::coefficient ( dimension_type  n  )  const [inline]

Returns the coefficient $a_n$.

Definition at line 247 of file Linear_Row.inlines.hh.

Referenced by Parma_Polyhedra_Library::Polyhedron::constrains().

00247                                                     {
00248   return (*this)[k+1];
00249 }

void Parma_Polyhedra_Library::Linear_Row::construct ( dimension_type  sz,
dimension_type  capacity,
Flags  f 
) [inline]

Constructs properly a default-constructed element.

Parameters:
sz The size of the row that will be constructed;
capacity The minimum capacity of the row that will be constructed.
f Flags for the row that will be constructed.

The row that we are constructing has a minimum capacity, i.e., it can contain at least capacity elements, sz of which will be default-constructed now. The row flags are set to f.

Reimplemented from Parma_Polyhedra_Library::Row.

Definition at line 164 of file Linear_Row.inlines.hh.

References construct().

00165                                      {
00166   Row::construct(sz, capacity, f);
00167 }

void Parma_Polyhedra_Library::Linear_Row::construct ( dimension_type  sz,
Flags  f 
) [inline]

Constructs properly a default-constructed element.

Builds a row with type t, size sz and minimum capacity.

Reimplemented from Parma_Polyhedra_Library::Row.

Definition at line 176 of file Linear_Row.inlines.hh.

Referenced by construct(), Parma_Polyhedra_Library::Linear_Expression::Linear_Expression(), and Linear_Row().

00176                                                             {
00177   construct(sz, sz, f);
00178 }

Linear_Row::Flags & Parma_Polyhedra_Library::Linear_Row::flags (  )  [inline]

Returns a non-const reference to the flags of *this.

Reimplemented from Parma_Polyhedra_Library::Row.

Definition at line 134 of file Linear_Row.inlines.hh.

References flags().

00134                   {
00135   return static_cast<Flags&>(Row::flags());
00136 }

const Linear_Row::Flags & Parma_Polyhedra_Library::Linear_Row::flags (  )  const [inline]
Coefficient_traits::const_reference Parma_Polyhedra_Library::Linear_Row::inhomogeneous_term (  )  const [inline]

Returns the inhomogeneous term.

Reimplemented in Parma_Polyhedra_Library::Linear_Expression, and Parma_Polyhedra_Library::Constraint.

Definition at line 242 of file Linear_Row.inlines.hh.

Referenced by Parma_Polyhedra_Library::Generator::divisor().

00242                                      {
00243   return (*this)[0];
00244 }

bool Parma_Polyhedra_Library::Linear_Row::is_line_or_equality (  )  const [inline]
bool Parma_Polyhedra_Library::Linear_Row::is_necessarily_closed (  )  const [inline]
bool Parma_Polyhedra_Library::Linear_Row::is_not_necessarily_closed (  )  const

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

bool Parma_Polyhedra_Library::Linear_Row::is_ray_or_point_or_inequality (  )  const [inline]
bool Parma_Polyhedra_Library::Linear_Row::is_zero (  )  const

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

Reimplemented in Parma_Polyhedra_Library::Linear_Expression.

Definition at line 126 of file Linear_Row.cc.

References Parma_Polyhedra_Library::Row::size().

00126                              {
00127   const Linear_Row& x = *this;
00128   for (dimension_type i = x.size(); i-- > 0; )
00129     if (x[i] != 0)
00130       return false;
00131   return true;
00132 }

void Parma_Polyhedra_Library::Linear_Row::linear_combine ( const Linear_Row y,
dimension_type  k 
)

Linearly combines *this with y so that *this[k] is 0.

Parameters:
y The Linear_Row that will be combined with *this object;
k The position of *this that have to be $0$.

Computes a linear combination of *this and y having the element of index k equal to $0$. Then it assigns the resulting Linear_Row to *this and normalizes it.

Definition at line 104 of file Linear_Row.cc.

References Parma_Polyhedra_Library::normalize2(), PPL_DIRTY_TEMP_COEFFICIENT, Parma_Polyhedra_Library::Row::size(), strong_normalize(), and Parma_Polyhedra_Library::sub_mul_assign().

Referenced by Parma_Polyhedra_Library::Linear_System::back_substitute(), and Parma_Polyhedra_Library::Polyhedron::BHRZ03_evolving_points().

00104                                                                          {
00105   Linear_Row& x = *this;
00106   // We can combine only vector of the same dimension.
00107   PPL_ASSERT(x.size() == y.size());
00108   PPL_ASSERT(y[k] != 0 && x[k] != 0);
00109   // Let g be the GCD between `x[k]' and `y[k]'.
00110   // For each i the following computes
00111   //   x[i] = x[i]*y[k]/g - y[i]*x[k]/g.
00112   PPL_DIRTY_TEMP_COEFFICIENT(normalized_x_k);
00113   PPL_DIRTY_TEMP_COEFFICIENT(normalized_y_k);
00114   normalize2(x[k], y[k], normalized_x_k, normalized_y_k);
00115   for (dimension_type i = size(); i-- > 0; )
00116     if (i != k) {
00117       Coefficient& x_i = x[i];
00118       x_i *= normalized_y_k;
00119       sub_mul_assign(x_i, y[i], normalized_x_k);
00120     }
00121   x[k] = 0;
00122   x.strong_normalize();
00123 }

dimension_type Parma_Polyhedra_Library::Linear_Row::max_space_dimension (  )  [inline, static]

Returns the maximum space dimension a Linear_Row can handle.

Reimplemented in Parma_Polyhedra_Library::Linear_Expression, Parma_Polyhedra_Library::Constraint, Parma_Polyhedra_Library::Generator, and Parma_Polyhedra_Library::Grid_Generator.

Definition at line 144 of file Linear_Row.inlines.hh.

References Parma_Polyhedra_Library::Row::max_size().

00144                                 {
00145   // The first coefficient holds the inhomogeneous term or the divisor.
00146   // In NNC rows, the last coefficient is for the epsilon dimension.
00147   return max_size() - 2;
00148 }

bool Parma_Polyhedra_Library::Linear_Row::OK ( dimension_type  row_size,
dimension_type  row_capacity 
) const

Checks if all the invariants are satisfied and that the actual size and capacity match the values provided as arguments.

Reimplemented from Parma_Polyhedra_Library::Row.

Definition at line 235 of file Linear_Row.cc.

References OK().

00236                                                              {
00237   return Row::OK(row_size, row_capacity);
00238 }

bool Parma_Polyhedra_Library::Linear_Row::OK (  )  const
void Parma_Polyhedra_Library::Linear_Row::print (  )  const
void Parma_Polyhedra_Library::Linear_Row::set_is_line_or_equality (  )  [inline]
void Parma_Polyhedra_Library::Linear_Row::set_is_ray_or_point_or_inequality (  )  [inline]
void Parma_Polyhedra_Library::Linear_Row::set_necessarily_closed (  )  [inline]

Sets to NECESSARILY_CLOSED the topological kind of *this row.

Definition at line 232 of file Linear_Row.inlines.hh.

References flags(), and Parma_Polyhedra_Library::Linear_Row::Flags::set_necessarily_closed().

00232                                    {
00233   flags().set_necessarily_closed();
00234 }

void Parma_Polyhedra_Library::Linear_Row::set_not_necessarily_closed (  )  [inline]

Sets to NOT_NECESSARILY_CLOSED the topological kind of *this row.

Definition at line 237 of file Linear_Row.inlines.hh.

References flags(), and Parma_Polyhedra_Library::Linear_Row::Flags::set_not_necessarily_closed().

00237                                        {
00238   flags().set_not_necessarily_closed();
00239 }

void Parma_Polyhedra_Library::Linear_Row::sign_normalize (  ) 

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

Definition at line 34 of file Linear_Row.cc.

References is_line_or_equality(), Parma_Polyhedra_Library::neg_assign(), and Parma_Polyhedra_Library::Row::size().

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

00034                               {
00035   if (is_line_or_equality()) {
00036     Linear_Row& x = *this;
00037     const dimension_type sz = x.size();
00038     // `first_non_zero' indicates the index of the first
00039     // coefficient of the row different from zero, disregarding
00040     // the very first coefficient (inhomogeneous term / divisor).
00041     dimension_type first_non_zero;
00042     for (first_non_zero = 1; first_non_zero < sz; ++first_non_zero)
00043       if (x[first_non_zero] != 0)
00044         break;
00045     if (first_non_zero < sz)
00046       // If the first non-zero coefficient of the row is negative,
00047       // we negate the entire row.
00048       if (x[first_non_zero] < 0) {
00049         for (dimension_type j = first_non_zero; j < sz; ++j)
00050           neg_assign(x[j]);
00051         // Also negate the first coefficient.
00052         neg_assign(x[0]);
00053       }
00054   }
00055 }

dimension_type Parma_Polyhedra_Library::Linear_Row::space_dimension (  )  const [inline]

Returns the dimension of the vector space enclosing *this.

Reimplemented in Parma_Polyhedra_Library::Linear_Expression, Parma_Polyhedra_Library::Constraint, Parma_Polyhedra_Library::Generator, and Parma_Polyhedra_Library::Grid_Generator.

Definition at line 151 of file Linear_Row.inlines.hh.

References is_necessarily_closed(), and Parma_Polyhedra_Library::Row::size().

00151                                   {
00152   const dimension_type sz = size();
00153   return (sz == 0)
00154     ? 0
00155     : sz - (is_necessarily_closed() ? 1 : 2);
00156 }

void Parma_Polyhedra_Library::Linear_Row::strong_normalize (  )  [inline]
Topology Parma_Polyhedra_Library::Linear_Row::topology (  )  const [inline]

Friends And Related Function Documentation

int compare ( const Linear_Row x,
const Linear_Row y 
) [related]

The basic comparison function.

Returns:
The returned absolute value can be $0$, $1$ or $2$.
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:

  1. equalities are smaller than inequalities;
  2. lines are smaller than points and rays;
  3. the ordering is lexicographic;
  4. the positions compared are, in decreasing order of significance, 1, 2, ..., size(), 0;
  5. the result is negative, zero, or positive if x is smaller than, equal to, or greater than y, respectively;
  6. 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.

Definition at line 66 of file Linear_Row.cc.

References Parma_Polyhedra_Library::cmp(), is_line_or_equality(), and Parma_Polyhedra_Library::Row::size().

Referenced by check_strong_normalized().

00066                                                      {
00067   const bool x_is_line_or_equality = x.is_line_or_equality();
00068   const bool y_is_line_or_equality = y.is_line_or_equality();
00069   if (x_is_line_or_equality != y_is_line_or_equality)
00070     // Equalities (lines) precede inequalities (ray/point).
00071     return y_is_line_or_equality ? 2 : -2;
00072 
00073   // Compare all the coefficients of the row starting from position 1.
00074   const dimension_type xsz = x.size();
00075   const dimension_type ysz = y.size();
00076   const dimension_type min_sz = std::min(xsz, ysz);
00077   dimension_type i;
00078   for (i = 1; i < min_sz; ++i)
00079     if (const int comp = cmp(x[i], y[i]))
00080       // There is at least a different coefficient.
00081       return (comp > 0) ? 2 : -2;
00082 
00083   // Handle the case where `x' and `y' are of different size.
00084   if (xsz != ysz) {
00085     for( ; i < xsz; ++i)
00086       if (const int sign = sgn(x[i]))
00087         return (sign > 0) ? 2 : -2;
00088     for( ; i < ysz; ++i)
00089       if (const int sign = sgn(y[i]))
00090         return (sign < 0) ? 2 : -2;
00091   }
00092 
00093   // If all the coefficients in `x' equal all the coefficients in `y'
00094   // (starting from position 1) we compare coefficients in position 0,
00095   // i.e., inhomogeneous terms.
00096   if (const int comp = cmp(x[0], y[0]))
00097     return (comp > 0) ? 1 : -1;
00098 
00099   // `x' and `y' are equal.
00100   return 0;
00101 }

void iter_swap ( std::vector< Parma_Polyhedra_Library::Linear_Row >::iterator  x,
std::vector< Parma_Polyhedra_Library::Linear_Row >::iterator  y 
) [related]

Specializes std::iter_swap.

Definition at line 284 of file Linear_Row.inlines.hh.

References Parma_Polyhedra_Library::swap().

00285                                                                   {
00286   swap(*x, *y);
00287 }

bool operator!= ( const Linear_Row x,
const Linear_Row y 
) [related]

Returns true if and only if x and y are different.

Definition at line 266 of file Linear_Row.inlines.hh.

00266                                                      {
00267   return !(x == y);
00268 }

bool operator== ( const Linear_Row x,
const Linear_Row y 
) [related]

Returns true if and only if x and y are equal.

Definition at line 259 of file Linear_Row.inlines.hh.

References flags().

00259                                                      {
00260   return x.flags() == y.flags()
00261     && static_cast<const Row&>(x) == static_cast<const Row&>(y);
00262 }

friend class Parma_Polyhedra_Library::Constraint [friend]

Reimplemented in Parma_Polyhedra_Library::Linear_Expression.

Definition at line 395 of file Linear_Row.defs.hh.

friend class Parma_Polyhedra_Library::Generator [friend]

Reimplemented in Parma_Polyhedra_Library::Linear_Expression.

Definition at line 396 of file Linear_Row.defs.hh.

Definition at line 394 of file Linear_Row.defs.hh.

Specializes std::swap.

Definition at line 277 of file Linear_Row.inlines.hh.

References swap().

Referenced by swap().

00278                                            {
00279   x.swap(y);
00280 }


The documentation for this class was generated from the following files:
Generated on Sun Feb 27 16:20:22 2011 for PPL by  doxygen 1.6.3