The base class for linear expressions, constraints and generators. More...
#include <Linear_Row.defs.hh>


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 . | |
| 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 . | |
| bool | all_homogeneous_terms_are_zero () const |
Returns true if and only if all the homogeneous terms of *this are . | |
| 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 Flags & | flags () const |
Returns a const reference to the flags of *this. | |
| Flags & | flags () |
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. | |
The base class for linear expressions, constraints and generators.
The class Linear_Row allows us to build objects of the form
, 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
represents the topology and the flag
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
, we have the following cases (
is the dimension of the vector space):
represents the equality constraint
.
represents the non-strict inequality constraint
.
represents the line of direction
.
represents the ray of direction
.
, with
, represents the point
.When
, the last coefficient of the Linear_Row is associated to the slack variable
, so that we have the following cases (
is again the dimension of the vector space, but this time we have
coefficients):
represents the equality constraint
.
represents the non-strict inequality constraint
.
, with
, represents the strict inequality constraint
.
represents the line of direction
.
represents the ray of direction
.
, with
and
, represents the point
.
, with
, represents the closure point
.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
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
-object on the vector space
as if it was a
-object on the vector space
, therefore interpreting the slack variable
as an ordinary dimension of the vector space.
A Linear_Row object implementing a Linear_Expression is always of the form
, which represents the linear expression
.
Definition at line 125 of file Linear_Row.defs.hh.
The possible kinds of Linear_Row objects.
Definition at line 128 of file Linear_Row.defs.hh.
00128 { 00129 LINE_OR_EQUALITY = 0, 00130 RAY_OR_POINT_OR_INEQUALITY = 1 00131 };
| 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] |
| bool Parma_Polyhedra_Library::Linear_Row::all_homogeneous_terms_are_zero | ( | ) | const |
Returns true if and only if all the homogeneous terms of *this are
.
Reimplemented in Parma_Polyhedra_Library::Linear_Expression, and Parma_Polyhedra_Library::Grid_Generator.
Definition at line 135 of file Linear_Row.cc.
References Parma_Polyhedra_Library::Row::size().
Referenced by Parma_Polyhedra_Library::Polyhedron::BFT00_poly_hull_assign_if_exact(), Parma_Polyhedra_Library::Constraint::is_inconsistent(), Parma_Polyhedra_Library::Constraint::is_tautological(), Parma_Polyhedra_Library::Generator::OK(), Parma_Polyhedra_Library::Generator_System::remove_invalid_lines_and_rays(), and Parma_Polyhedra_Library::Polyhedron::time_elapse_assign().
00135 { 00136 const Linear_Row& x = *this; 00137 for (dimension_type i = x.size(); --i > 0; ) 00138 if (x[i] != 0) 00139 return false; 00140 return true; 00141 }
| 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 |
Writes to std::cerr 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.
| 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
.
Definition at line 247 of file Linear_Row.inlines.hh.
Referenced by Parma_Polyhedra_Library::Polyhedron::constrains().
| void Parma_Polyhedra_Library::Linear_Row::construct | ( | dimension_type | sz, | |
| dimension_type | capacity, | |||
| Flags | f | |||
| ) | [inline] |
Constructs properly a default-constructed element.
| 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] |
Returns a const reference to the flags of *this.
Reimplemented from Parma_Polyhedra_Library::Row.
Definition at line 129 of file Linear_Row.inlines.hh.
Referenced by ascii_dump(), Parma_Polyhedra_Library::Constraint::Constraint(), flags(), Parma_Polyhedra_Library::Generator::Generator(), is_line_or_equality(), is_necessarily_closed(), is_ray_or_point_or_inequality(), operator==(), set_is_line_or_equality(), set_is_ray_or_point_or_inequality(), set_necessarily_closed(), set_not_necessarily_closed(), and topology().
00129 { 00130 return static_cast<const Flags&>(Row::flags()); 00131 }
| 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().
| bool Parma_Polyhedra_Library::Linear_Row::is_line_or_equality | ( | ) | const [inline] |
Returns true if and only if *this row represents a line or an equality.
Definition at line 207 of file Linear_Row.inlines.hh.
References flags(), and Parma_Polyhedra_Library::Linear_Row::Flags::is_line_or_equality().
Referenced by Parma_Polyhedra_Library::Polyhedron::BFT00_poly_hull_assign_if_exact(), compare(), Parma_Polyhedra_Library::Constraint::is_equality(), Parma_Polyhedra_Library::Generator::is_line(), and sign_normalize().
00207 { 00208 return flags().is_line_or_equality(); 00209 }
| bool Parma_Polyhedra_Library::Linear_Row::is_necessarily_closed | ( | ) | const [inline] |
Returns true if and only if the topology of *this row is necessarily closed.
Definition at line 139 of file Linear_Row.inlines.hh.
References flags(), and Parma_Polyhedra_Library::Linear_Row::Flags::is_necessarily_closed().
Referenced by Parma_Polyhedra_Library::Polyhedron::add_generator(), Parma_Polyhedra_Library::Generator::is_equivalent_to(), Parma_Polyhedra_Library::Constraint::is_inconsistent(), Parma_Polyhedra_Library::Constraint::is_tautological(), Parma_Polyhedra_Library::Grid_Generator::OK(), Parma_Polyhedra_Library::Generator::OK(), Parma_Polyhedra_Library::Topology_Adjusted_Scalar_Product_Sign::operator()(), Parma_Polyhedra_Library::Scalar_Products::reduced_assign(), Parma_Polyhedra_Library::Polyhedron::refine_no_check(), Parma_Polyhedra_Library::Polyhedron::refine_with_constraints(), space_dimension(), Parma_Polyhedra_Library::Generator::type(), and Parma_Polyhedra_Library::Constraint::type().
00139 { 00140 return flags().is_necessarily_closed(); 00141 }
| 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] |
Returns true if and only if *this row represents a ray, a point or an inequality.
Definition at line 212 of file Linear_Row.inlines.hh.
References flags(), and Parma_Polyhedra_Library::Linear_Row::Flags::is_ray_or_point_or_inequality().
Referenced by Parma_Polyhedra_Library::Polyhedron::conversion(), Parma_Polyhedra_Library::Constraint::is_inequality(), Parma_Polyhedra_Library::Grid_Generator::is_parameter_or_point(), and Parma_Polyhedra_Library::Generator::is_ray_or_point().
00212 { 00213 return flags().is_ray_or_point_or_inequality(); 00214 }
| bool Parma_Polyhedra_Library::Linear_Row::is_zero | ( | ) | const |
Returns true if and only if all the terms of *this are
.
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.
| y | The Linear_Row that will be combined with *this object; | |
| k | The position of *this that have to be . |
Computes a linear combination of *this and y having the element of index k equal to
. 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 |
Checks if all the invariants are satisfied.
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 230 of file Linear_Row.cc.
Referenced by OK(), Parma_Polyhedra_Library::Generator::OK(), and Parma_Polyhedra_Library::Constraint::OK().
00230 { 00231 return Row::OK(); 00232 }
| void Parma_Polyhedra_Library::Linear_Row::print | ( | ) | const |
Prints *this to std::cerr using operator<<.
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.
| void Parma_Polyhedra_Library::Linear_Row::set_is_line_or_equality | ( | ) | [inline] |
Sets to LINE_OR_EQUALITY the kind of *this row.
Definition at line 222 of file Linear_Row.inlines.hh.
References flags(), and Parma_Polyhedra_Library::Linear_Row::Flags::set_is_line_or_equality().
Referenced by Parma_Polyhedra_Library::Linear_System::add_rows_and_columns(), Parma_Polyhedra_Library::Polyhedron::minimize(), Parma_Polyhedra_Library::Constraint::set_is_equality(), Parma_Polyhedra_Library::Generator::set_is_line(), and Parma_Polyhedra_Library::Polyhedron::simplify_using_context_assign().
00222 { 00223 flags().set_is_line_or_equality(); 00224 }
| void Parma_Polyhedra_Library::Linear_Row::set_is_ray_or_point_or_inequality | ( | ) | [inline] |
Sets to RAY_OR_POINT_OR_INEQUALITY the kind of *this row.
Definition at line 227 of file Linear_Row.inlines.hh.
References flags(), and Parma_Polyhedra_Library::Linear_Row::Flags::set_is_ray_or_point_or_inequality().
Referenced by Parma_Polyhedra_Library::Polyhedron::BFT00_poly_hull_assign_if_exact(), Parma_Polyhedra_Library::Constraint::set_is_inequality(), and Parma_Polyhedra_Library::Generator::set_is_ray_or_point().
00227 { 00228 flags().set_is_ray_or_point_or_inequality(); 00229 }
| 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] |
Strong normalization: ensures that different Linear_Row objects represent different hyperplanes or hyperspaces.
Applies both Linear_Row::normalize() and Linear_Row::sign_normalize().
Reimplemented in Parma_Polyhedra_Library::Grid_Generator.
Definition at line 252 of file Linear_Row.inlines.hh.
References Parma_Polyhedra_Library::Row::normalize(), and sign_normalize().
Referenced by Parma_Polyhedra_Library::Polyhedron::add_congruence(), Parma_Polyhedra_Library::Polyhedron::add_congruences(), check_strong_normalized(), Parma_Polyhedra_Library::Constraint::Constraint(), Parma_Polyhedra_Library::Polyhedron::conversion(), linear_combine(), Parma_Polyhedra_Library::Generator::OK(), Parma_Polyhedra_Library::Constraint::OK(), Parma_Polyhedra_Library::Polyhedron::refine_with_congruence(), and Parma_Polyhedra_Library::Polyhedron::refine_with_congruences().
00252 { 00253 normalize(); 00254 sign_normalize(); 00255 }
| Topology Parma_Polyhedra_Library::Linear_Row::topology | ( | ) | const [inline] |
Returns the topological kind of *this.
Definition at line 217 of file Linear_Row.inlines.hh.
References flags(), and Parma_Polyhedra_Library::Linear_Row::Flags::topology().
Referenced by Parma_Polyhedra_Library::Linear_System::insert(), Parma_Polyhedra_Library::Generator_System::insert(), Parma_Polyhedra_Library::Constraint_System::insert(), Parma_Polyhedra_Library::Linear_System::insert_pending(), Parma_Polyhedra_Library::Generator_System::insert_pending(), Parma_Polyhedra_Library::Constraint_System::insert_pending(), and Parma_Polyhedra_Library::Generator::is_matching_closure_point().
| int compare | ( | const Linear_Row & | x, | |
| const Linear_Row & | y | |||
| ) | [related] |
The basic comparison function.
,
or
.| 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:
size(), 0;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:
x is smaller than y and they are not parallel;x is smaller than y and they are parallel;x and y are equal;y is smaller than x and they are parallel;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.
| 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.
friend class Parma_Polyhedra_Library::Linear_Expression [friend] |
Definition at line 394 of file Linear_Row.defs.hh.
| void swap | ( | Parma_Polyhedra_Library::Linear_Row & | x, | |
| Parma_Polyhedra_Library::Linear_Row & | y | |||
| ) | [related] |
Specializes std::swap.
Definition at line 277 of file Linear_Row.inlines.hh.
References swap().
Referenced by swap().
00278 { 00279 x.swap(y); 00280 }
1.6.3