Parma_Polyhedra_Library::OR_Matrix< T > Class Template Reference

A matrix representing octagonal constraints. More...

#include <OR_Matrix.defs.hh>

Inheritance diagram for Parma_Polyhedra_Library::OR_Matrix< T >:

[legend]

List of all members.

Public Types
typedef Pseudo_Row< T >	row_reference_type
	A (non const) reference to a matrix's row.
typedef Pseudo_Row< const T >	const_row_reference_type
	A const reference to a matrix's row.
typedef any_row_iterator< T >	row_iterator
	A (non const) row iterator.
typedef any_row_iterator< const T >	const_row_iterator
	A const row iterator.
typedef DB_Row< T >::iterator	element_iterator
	A (non const) element iterator.
typedef DB_Row< T >::const_iterator	const_element_iterator
	A const element iterator.
Public Member Functions
	OR_Matrix (dimension_type space_dim)
	Builds a matrix with specified dimensions.
	OR_Matrix (const OR_Matrix &y)
	Copy-constructor.
template<typename U>
	OR_Matrix (const OR_Matrix< U > &y)
	Constructs a conservative approximation of y.
	~OR_Matrix ()
	Destructor.
OR_Matrix &	operator= (const OR_Matrix &y)
	Assignment operator.
void	swap (OR_Matrix &y)
	Swaps *this with y.
void	grow (dimension_type new_dim)
	Makes the matrix grow by adding more space dimensions.
void	shrink (dimension_type new_dim)
	Makes the matrix shrink by removing the last space dimensions.
void	resize_no_copy (dimension_type new_dim)
	Resizes the matrix without worrying about the old contents.
dimension_type	space_dimension () const
	Returns the space-dimension of the matrix.
dimension_type	num_rows () const
	Returns the number of rows in the matrix.
row_iterator	row_begin ()
	Returns an iterator pointing to the first row, if *this is not empty; otherwise, returns the past-the-end const_iterator.
row_iterator	row_end ()
	Returns the past-the-end const_iterator.
const_row_iterator	row_begin () const
	Returns a const row iterator pointing to the first row, if *this is not empty; otherwise, returns the past-the-end const_iterator.
const_row_iterator	row_end () const
	Returns the past-the-end const row iterator.
element_iterator	element_begin ()
	Returns an iterator pointing to the first element, if *this is not empty; otherwise, returns the past-the-end const_iterator.
element_iterator	element_end ()
	Returns the past-the-end const_iterator.
const_element_iterator	element_begin () const
	Returns a const element iterator pointing to the first element, if *this is not empty; otherwise, returns the past-the-end const_iterator.
const_element_iterator	element_end () const
	Returns the past-the-end const element iterator.
void	clear ()
	Clears the matrix deallocating all its rows.
void	ascii_dump () const
	Writes to std::cerr an ASCII representation of *this.
void	ascii_dump (std::ostream &s) const
	Writes to s an ASCII representation of *this.
void	print () const
	Prints *this to std::cerr using operator<<.
bool	ascii_load (std::istream &s)
	Loads from s an ASCII representation (as produced by ascii_dump(std::ostream&) const) and sets *this accordingly. Returns true if successful, false otherwise.
memory_size_type	total_memory_in_bytes () const
	Returns the total size in bytes of the memory occupied by *this.
memory_size_type	external_memory_in_bytes () const
	Returns the size in bytes of the memory managed by *this.
bool	OK () const
	Checks if all the invariants are satisfied.
Subscript operators.
row_reference_type	operator[] (dimension_type k)
	Returns a reference to the k-th row of the matrix.
const_row_reference_type	operator[] (dimension_type k) const
	Returns a constant reference to the k-th row of the matrix.
Static Public Member Functions
static dimension_type	max_num_rows ()
	Returns the maximum number of rows of a OR_Matrix.
static dimension_type	row_size (dimension_type k)
	Returns the size of the row of index k.
Private Member Functions
	OR_Matrix ()
	Private and not implemented: default construction is not allowed.
Static Private Member Functions
static dimension_type	row_first_element_index (dimension_type k)
	Returns the index into vec of the first element of the row of index k.
Private Attributes
DB_Row< T >	vec
	Contains the rows of the matrix.
dimension_type	space_dim
	Contains the dimension of the space of the matrix.
dimension_type	vec_capacity
	Contains the capacity of vec.
Friends
class	OR_Matrix
bool	operator== (const OR_Matrix< T > &x, const OR_Matrix< T > &y)
	Returns true if and only if x and y are identical.
Related Functions
(Note that these are not member functions.)
template<typename T>
std::ostream &	operator<< (std::ostream &s, const OR_Matrix< T > &m)
	Output operator.
template<typename T>
void	swap (Parma_Polyhedra_Library::OR_Matrix< T > &x, Parma_Polyhedra_Library::OR_Matrix< T > &y)
	Specializes std::swap.
template<typename T>
bool	operator!= (const OR_Matrix< T > &x, const OR_Matrix< T > &y)
	Returns true if and only if x and y are different.
template<typename Temp, typename To, typename T>
bool	rectilinear_distance_assign (Checked_Number< To, Extended_Number_Policy > &r, const OR_Matrix< T > &x, const OR_Matrix< T > &y, Rounding_Dir dir, Temp &tmp0, Temp &tmp1, Temp &tmp2)
	Computes the rectilinear (or Manhattan) distance between x and y.
template<typename Temp, typename To, typename T>
bool	euclidean_distance_assign (Checked_Number< To, Extended_Number_Policy > &r, const OR_Matrix< T > &x, const OR_Matrix< T > &y, Rounding_Dir dir, Temp &tmp0, Temp &tmp1, Temp &tmp2)
	Computes the euclidean distance between x and y.
template<typename Temp, typename To, typename T>
bool	l_infinity_distance_assign (Checked_Number< To, Extended_Number_Policy > &r, const OR_Matrix< T > &x, const OR_Matrix< T > &y, Rounding_Dir dir, Temp &tmp0, Temp &tmp1, Temp &tmp2)
	Computes the distance between x and y.
template<typename Specialization, typename Temp, typename To, typename T>
bool	l_m_distance_assign (Checked_Number< To, Extended_Number_Policy > &r, const OR_Matrix< T > &x, const OR_Matrix< T > &y, const Rounding_Dir dir, Temp &tmp0, Temp &tmp1, Temp &tmp2)
Classes
class	any_row_iterator
	A template class to derive both OR_Matrix::iterator and OR_Matrix::const_iterator. More...
class	Pseudo_Row
	An object that behaves like a matrix's row with respect to the subscript operators. More...

---

Detailed Description

template<typename T>
class Parma_Polyhedra_Library::OR_Matrix< T >

A matrix representing octagonal constraints.

An OR_Matrix object is a DB_Row object that allows the representation of a pseudo-triangular matrix, like the following:

         _ _
   0    |_|_|
   1    |_|_|_ _
   2    |_|_|_|_|
   3    |_|_|_|_|_ _
   4    |_|_|_|_|_|_|
   5    |_|_|_|_|_|_|
         . . .
         _ _ _ _ _ _       _
 2n-2   |_|_|_|_|_|_| ... |_|
 2n-1   |_|_|_|_|_|_| ... |_|
         0 1 2 3 4 5  ... 2n-1

It is characterized by parameter n that defines the structure, and such that there are 2*n rows (and 2*n columns). It provides row_iterators for the access to the rows and element_iterators for the access to the elements.

Definition at line 105 of file OR_Matrix.defs.hh.

---

Member Typedef Documentation

template<typename T>

typedef Pseudo_Row<T> Parma_Polyhedra_Library::OR_Matrix< T >::row_reference_type

A (non const) reference to a matrix's row.

Definition at line 190 of file OR_Matrix.defs.hh.

template<typename T>

typedef Pseudo_Row<const T> Parma_Polyhedra_Library::OR_Matrix< T >::const_row_reference_type

A const reference to a matrix's row.

Definition at line 193 of file OR_Matrix.defs.hh.

template<typename T>

typedef any_row_iterator<T> Parma_Polyhedra_Library::OR_Matrix< T >::row_iterator

A (non const) row iterator.

Definition at line 322 of file OR_Matrix.defs.hh.

template<typename T>

typedef any_row_iterator<const T> Parma_Polyhedra_Library::OR_Matrix< T >::const_row_iterator

A const row iterator.

Definition at line 325 of file OR_Matrix.defs.hh.

template<typename T>

typedef DB_Row<T>::iterator Parma_Polyhedra_Library::OR_Matrix< T >::element_iterator

A (non const) element iterator.

Definition at line 328 of file OR_Matrix.defs.hh.

template<typename T>

typedef DB_Row<T>::const_iterator Parma_Polyhedra_Library::OR_Matrix< T >::const_element_iterator

A const element iterator.

Definition at line 331 of file OR_Matrix.defs.hh.

---

Constructor & Destructor Documentation

template<typename T>

Parma_Polyhedra_Library::OR_Matrix< T >::OR_Matrix

(

dimension_type

space_dim

)

[inline]

Builds a matrix with specified dimensions.

Parameters:

space_dim

The space dimension of the matrix that will be created.

This constructor creates a matrix with 2*space_dim rows. Each element is initialized to plus infinity.

Definition at line 436 of file OR_Matrix.inlines.hh.

  : vec(2*dim*(dim+1)),
    space_dim(dim),
    vec_capacity(vec.size()) {
}

template<typename T>

Parma_Polyhedra_Library::OR_Matrix< T >::OR_Matrix

(

const OR_Matrix< T > &

y

)

[inline]

Copy-constructor.

Definition at line 505 of file OR_Matrix.inlines.hh.

  : vec(y.vec),
    space_dim(y.space_dim),
    vec_capacity(compute_capacity(y.vec.size())) {
}

template<typename T>

template<typename U>

Parma_Polyhedra_Library::OR_Matrix< T >::OR_Matrix

(

const OR_Matrix< U > &

y

)

[inline, explicit]

Constructs a conservative approximation of y.

Definition at line 514 of file OR_Matrix.inlines.hh.

References Parma_Polyhedra_Library::OR_Matrix< T >::OK(), Parma_Polyhedra_Library::OR_Matrix< T >::vec, and Parma_Polyhedra_Library::OR_Matrix< T >::vec_capacity.

  : vec(),
    space_dim(y.space_dim),
    vec_capacity(compute_capacity(y.vec.size())) {
  vec.construct_upward_approximation(y.vec, vec_capacity);
  assert(OK());
}

template<typename T>

Parma_Polyhedra_Library::OR_Matrix< T >::~OR_Matrix

(

)

[inline]

Destructor.

Definition at line 444 of file OR_Matrix.inlines.hh.

                         {
}

template<typename T>

Parma_Polyhedra_Library::OR_Matrix< T >::OR_Matrix

(

)

[private]

Private and not implemented: default construction is not allowed.

---

Member Function Documentation

template<typename T>

dimension_type Parma_Polyhedra_Library::OR_Matrix< T >::max_num_rows

(

)

[inline, static]

Returns the maximum number of rows of a OR_Matrix.

Definition at line 420 of file OR_Matrix.inlines.hh.

References Parma_Polyhedra_Library::isqrt().

                           {
  // Compute the maximum number of rows that
  // are contained in a DB_Row that allocates
  // a pseudo-triangular matrix.
  dimension_type k = isqrt(2*DB_Row<T>::max_size() + 1);
  return (k-1) & ~dimension_type(1);
}

template<typename T>

OR_Matrix< T > & Parma_Polyhedra_Library::OR_Matrix< T >::operator=

(

const OR_Matrix< T > &

y

)

[inline]

Assignment operator.

Definition at line 524 of file OR_Matrix.inlines.hh.

References Parma_Polyhedra_Library::compute_capacity(), Parma_Polyhedra_Library::OR_Matrix< T >::space_dim, Parma_Polyhedra_Library::OR_Matrix< T >::vec, and Parma_Polyhedra_Library::OR_Matrix< T >::vec_capacity.

                                          {
  vec = y.vec;
  space_dim = y.space_dim;
  vec_capacity = compute_capacity(y.vec.size());
  return *this;
}

template<typename T>

dimension_type Parma_Polyhedra_Library::OR_Matrix< T >::row_first_element_index

(

dimension_type

k

)

[inline, static, private]

Returns the index into vec of the first element of the row of index k.

Definition at line 39 of file OR_Matrix.inlines.hh.

Referenced by Parma_Polyhedra_Library::OR_Matrix< T >::operator[]().

                                                            {
  return ((k+1)*(k+1))/2;
}

template<typename T>

dimension_type Parma_Polyhedra_Library::OR_Matrix< T >::row_size

(

dimension_type

k

)

[inline, static]

Returns the size of the row of index k.

Definition at line 45 of file OR_Matrix.inlines.hh.

Referenced by Parma_Polyhedra_Library::Octagonal_Shape< T >::add_octagonal_constraint(), Parma_Polyhedra_Library::Octagonal_Shape< T >::constrains(), Parma_Polyhedra_Library::Octagonal_Shape< T >::forget_all_octagonal_constraints(), Parma_Polyhedra_Library::OR_Matrix< T >::any_row_iterator< U >::operator+=(), and Parma_Polyhedra_Library::OR_Matrix< T >::operator[]().

                                             {
  return (k+2) & ~dimension_type(1);
}

template<typename T>

void Parma_Polyhedra_Library::OR_Matrix< T >::swap

(

OR_Matrix< T > &

y

)

[inline]

Swaps *this with y.

Definition at line 397 of file OR_Matrix.inlines.hh.

References Parma_Polyhedra_Library::OR_Matrix< T >::space_dim, Parma_Polyhedra_Library::swap(), Parma_Polyhedra_Library::OR_Matrix< T >::vec, and Parma_Polyhedra_Library::OR_Matrix< T >::vec_capacity.

Referenced by Parma_Polyhedra_Library::OR_Matrix< T >::clear(), Parma_Polyhedra_Library::OR_Matrix< T >::grow(), Parma_Polyhedra_Library::OR_Matrix< T >::resize_no_copy(), and Parma_Polyhedra_Library::OR_Matrix< T >::swap().

                               {
  std::swap(vec, y.vec);
  std::swap(space_dim, y.space_dim);
  std::swap(vec_capacity, y.vec_capacity);
}

template<typename T>

void Parma_Polyhedra_Library::OR_Matrix< T >::grow

(

dimension_type

new_dim

)

[inline]

Makes the matrix grow by adding more space dimensions.

Parameters:

new_dim

The new dimension of the resized matrix.

Adds new rows of right dimension to the end if there is enough capacity; otherwise, creates a new matrix, with the specified dimension, copying the old elements in the upper part of the new matrix, which is then assigned to *this. Each new element is initialized to plus infinity.

Definition at line 533 of file OR_Matrix.inlines.hh.

References Parma_Polyhedra_Library::OR_Matrix< T >::element_begin(), Parma_Polyhedra_Library::OR_Matrix< T >::element_end(), Parma_Polyhedra_Library::OR_Matrix< T >::space_dim, Parma_Polyhedra_Library::OR_Matrix< T >::swap(), Parma_Polyhedra_Library::OR_Matrix< T >::vec, and Parma_Polyhedra_Library::OR_Matrix< T >::vec_capacity.

                                               {
  assert(new_dim >= space_dim);
  if (new_dim > space_dim) {
    const dimension_type new_size = 2*new_dim*(new_dim + 1);
    if (new_size <= vec_capacity) {
      // We can recycle the old vec.
      vec.expand_within_capacity(new_size);
      space_dim = new_dim;
    }
    else {
      // We cannot recycle the old vec.
      OR_Matrix<T> new_matrix(new_dim);
      element_iterator j = new_matrix.element_begin();
      for (element_iterator i = element_begin(),
             mend = element_end(); i != mend; ++i, ++j)
        assign_or_swap(*j, *i);
      swap(new_matrix);
    }
  }
}

template<typename T>

void Parma_Polyhedra_Library::OR_Matrix< T >::shrink

(

dimension_type

new_dim

)

[inline]

Makes the matrix shrink by removing the last space dimensions.

Parameters:

new_dim

The new dimension of the resized matrix.

Erases from matrix to the end the rows with index greater than 2*new_dim-1.

Definition at line 556 of file OR_Matrix.inlines.hh.

References Parma_Polyhedra_Library::OR_Matrix< T >::space_dim, and Parma_Polyhedra_Library::OR_Matrix< T >::vec.

Referenced by Parma_Polyhedra_Library::OR_Matrix< T >::resize_no_copy().

                                                 {
  assert(new_dim <= space_dim);
  const dimension_type new_size = 2*new_dim*(new_dim + 1);
  vec.shrink(new_size);
  space_dim = new_dim;
}

template<typename T>

void Parma_Polyhedra_Library::OR_Matrix< T >::resize_no_copy

(

dimension_type

new_dim

)

[inline]

Resizes the matrix without worrying about the old contents.

Parameters:

new_dim

The new dimension of the resized matrix.

If the new dimension is greater than the old one, it adds new rows of right dimension to the end if there is enough capacity; otherwise, it creates a new matrix, with the specified dimension, which is then assigned to *this. If the new dimension is less than the old one, it erase from the matrix the rows having index greater than 2*new_dim-1

Definition at line 565 of file OR_Matrix.inlines.hh.

References Parma_Polyhedra_Library::OR_Matrix< T >::shrink(), Parma_Polyhedra_Library::OR_Matrix< T >::space_dim, Parma_Polyhedra_Library::OR_Matrix< T >::swap(), Parma_Polyhedra_Library::OR_Matrix< T >::vec, and Parma_Polyhedra_Library::OR_Matrix< T >::vec_capacity.

Referenced by Parma_Polyhedra_Library::OR_Matrix< T >::ascii_load().

                                                         {
  if (new_dim > space_dim) {
    const dimension_type new_size = 2*new_dim*(new_dim + 1);
    if (new_size <= vec_capacity) {
      // We can recycle the old vec.
      vec.expand_within_capacity(new_size);
      space_dim = new_dim;
    }
    else {
      // We cannot recycle the old vec.
      OR_Matrix<T> new_matrix(new_dim);
      swap(new_matrix);
    }
  }
  else if (new_dim < space_dim)
    shrink(new_dim);
}

template<typename T>

dimension_type Parma_Polyhedra_Library::OR_Matrix< T >::space_dimension

(

)

const [inline]

Returns the space-dimension of the matrix.

Definition at line 469 of file OR_Matrix.inlines.hh.

References Parma_Polyhedra_Library::OR_Matrix< T >::space_dim.

Referenced by Parma_Polyhedra_Library::OR_Matrix< T >::ascii_dump(), Parma_Polyhedra_Library::OR_Matrix< T >::num_rows(), and Parma_Polyhedra_Library::OR_Matrix< T >::OK().

                                    {
  return space_dim;
}

template<typename T>

dimension_type Parma_Polyhedra_Library::OR_Matrix< T >::num_rows

(

)

const [inline]

Returns the number of rows in the matrix.

Definition at line 475 of file OR_Matrix.inlines.hh.

References Parma_Polyhedra_Library::OR_Matrix< T >::space_dimension().

Referenced by Parma_Polyhedra_Library::OR_Matrix< T >::l_m_distance_assign(), Parma_Polyhedra_Library::OR_Matrix< T >::row_begin(), and Parma_Polyhedra_Library::OR_Matrix< T >::row_end().

                             {
  return 2*space_dimension();
}

template<typename T>

OR_Matrix< T >::row_reference_type Parma_Polyhedra_Library::OR_Matrix< T >::operator[]

(

dimension_type

k

)

[inline]

Returns a reference to the k-th row of the matrix.

Definition at line 449 of file OR_Matrix.inlines.hh.

References PPL_OR_MATRIX_EXTRA_DEBUG, Parma_Polyhedra_Library::OR_Matrix< T >::row_first_element_index(), Parma_Polyhedra_Library::OR_Matrix< T >::row_size(), and Parma_Polyhedra_Library::OR_Matrix< T >::vec.

                                         {
  return row_reference_type(vec[row_first_element_index(k)]
#if PPL_OR_MATRIX_EXTRA_DEBUG
                            , row_size(k)
#endif
                            );
}

template<typename T>

OR_Matrix< T >::const_row_reference_type Parma_Polyhedra_Library::OR_Matrix< T >::operator[]

(

dimension_type

k

)

const [inline]

Returns a constant reference to the k-th row of the matrix.

Definition at line 459 of file OR_Matrix.inlines.hh.

References PPL_OR_MATRIX_EXTRA_DEBUG, Parma_Polyhedra_Library::OR_Matrix< T >::row_first_element_index(), Parma_Polyhedra_Library::OR_Matrix< T >::row_size(), and Parma_Polyhedra_Library::OR_Matrix< T >::vec.

                                               {
  return const_row_reference_type(vec[row_first_element_index(k)]
#if PPL_OR_MATRIX_EXTRA_DEBUG
                                  , row_size(k)
#endif
                                  );
}

template<typename T>

OR_Matrix< T >::row_iterator Parma_Polyhedra_Library::OR_Matrix< T >::row_begin

(

)

[inline]

Returns an iterator pointing to the first row, if *this is not empty; otherwise, returns the past-the-end const_iterator.

Definition at line 349 of file OR_Matrix.inlines.hh.

References Parma_Polyhedra_Library::OR_Matrix< T >::num_rows(), and Parma_Polyhedra_Library::OR_Matrix< T >::vec.

Referenced by Parma_Polyhedra_Library::OR_Matrix< T >::ascii_dump(), Parma_Polyhedra_Library::OR_Matrix< T >::ascii_load(), Parma_Polyhedra_Library::Octagonal_Shape< T >::get_limiting_octagon(), and Parma_Polyhedra_Library::Octagonal_Shape< T >::map_space_dimensions().

                        {
  return num_rows() == 0 ? row_iterator(0) : row_iterator(vec[0]);
}

template<typename T>

OR_Matrix< T >::row_iterator Parma_Polyhedra_Library::OR_Matrix< T >::row_end

(

)

[inline]

Returns the past-the-end const_iterator.

Definition at line 355 of file OR_Matrix.inlines.hh.

References Parma_Polyhedra_Library::OR_Matrix< T >::num_rows().

Referenced by Parma_Polyhedra_Library::OR_Matrix< T >::ascii_dump(), Parma_Polyhedra_Library::OR_Matrix< T >::ascii_load(), and Parma_Polyhedra_Library::Octagonal_Shape< T >::map_space_dimensions().

                      {
  return row_iterator(num_rows());
}

template<typename T>

OR_Matrix< T >::const_row_iterator Parma_Polyhedra_Library::OR_Matrix< T >::row_begin

(

)

const [inline]

Returns a const row iterator pointing to the first row, if *this is not empty; otherwise, returns the past-the-end const_iterator.

Definition at line 361 of file OR_Matrix.inlines.hh.

References Parma_Polyhedra_Library::OR_Matrix< T >::num_rows(), and Parma_Polyhedra_Library::OR_Matrix< T >::vec.

                              {
  return num_rows() == 0 ? const_row_iterator(0) : const_row_iterator(vec[0]);
}

template<typename T>

OR_Matrix< T >::const_row_iterator Parma_Polyhedra_Library::OR_Matrix< T >::row_end

(

)

const [inline]

Returns the past-the-end const row iterator.

Definition at line 367 of file OR_Matrix.inlines.hh.

References Parma_Polyhedra_Library::OR_Matrix< T >::num_rows().

                            {
  return const_row_iterator(num_rows());
}

template<typename T>

OR_Matrix< T >::element_iterator Parma_Polyhedra_Library::OR_Matrix< T >::element_begin

(

)

[inline]

Returns an iterator pointing to the first element, if *this is not empty; otherwise, returns the past-the-end const_iterator.

Definition at line 373 of file OR_Matrix.inlines.hh.

References Parma_Polyhedra_Library::OR_Matrix< T >::vec.

Referenced by Parma_Polyhedra_Library::OR_Matrix< T >::grow(), and Parma_Polyhedra_Library::OR_Matrix< T >::l_m_distance_assign().

                            {
  return vec.begin();
}

template<typename T>

OR_Matrix< T >::element_iterator Parma_Polyhedra_Library::OR_Matrix< T >::element_end

(

)

[inline]

Returns the past-the-end const_iterator.

Definition at line 379 of file OR_Matrix.inlines.hh.

References Parma_Polyhedra_Library::OR_Matrix< T >::vec.

Referenced by Parma_Polyhedra_Library::OR_Matrix< T >::grow(), and Parma_Polyhedra_Library::OR_Matrix< T >::l_m_distance_assign().

                          {
  return vec.end();
}

template<typename T>

OR_Matrix< T >::const_element_iterator Parma_Polyhedra_Library::OR_Matrix< T >::element_begin

(

)

const [inline]

Returns a const element iterator pointing to the first element, if *this is not empty; otherwise, returns the past-the-end const_iterator.

Definition at line 385 of file OR_Matrix.inlines.hh.

References Parma_Polyhedra_Library::OR_Matrix< T >::vec.

                                  {
  return vec.begin();
}

template<typename T>

OR_Matrix< T >::const_element_iterator Parma_Polyhedra_Library::OR_Matrix< T >::element_end

(

)

const [inline]

Returns the past-the-end const element iterator.

Definition at line 391 of file OR_Matrix.inlines.hh.

References Parma_Polyhedra_Library::OR_Matrix< T >::vec.

                                {
  return vec.end();
}

template<typename T>

void Parma_Polyhedra_Library::OR_Matrix< T >::clear

(

)

[inline]

Clears the matrix deallocating all its rows.

Definition at line 481 of file OR_Matrix.inlines.hh.

References Parma_Polyhedra_Library::OR_Matrix< T >::swap().

                    {
  OR_Matrix<T>(0).swap(*this);
}

template<typename T>

void Parma_Polyhedra_Library::OR_Matrix< T >::ascii_dump

(

)

const

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

template<typename T>

void Parma_Polyhedra_Library::OR_Matrix< T >::ascii_dump

(

std::ostream &

s

)

const [inline]

Writes to s an ASCII representation of *this.

Definition at line 64 of file OR_Matrix.templates.hh.

References Parma_Polyhedra_Library::OR_Matrix< T >::row_begin(), Parma_Polyhedra_Library::OR_Matrix< T >::row_end(), and Parma_Polyhedra_Library::OR_Matrix< T >::space_dimension().

                                            {
  const OR_Matrix<T>& x = *this;
  const char separator = ' ';
  dimension_type space = x.space_dimension();
  s << space << separator << "\n";
  for (const_row_iterator i = x.row_begin(),
         x_row_end = x.row_end(); i != x_row_end; ++i) {
    const_row_reference_type r = *i;
    dimension_type rs = i.row_size();
    for (dimension_type j = 0; j < rs; ++j) {
      using namespace IO_Operators;
      s << r[j] << separator;
    }
    s << "\n";
  }
}

template<typename T>

void Parma_Polyhedra_Library::OR_Matrix< T >::print

(

)

const

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

template<typename T>

bool Parma_Polyhedra_Library::OR_Matrix< T >::ascii_load

(

std::istream &

s

)

[inline]

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 85 of file OR_Matrix.templates.hh.

References Parma_Polyhedra_Library::OR_Matrix< T >::OK(), Parma_Polyhedra_Library::OR_Matrix< T >::resize_no_copy(), Parma_Polyhedra_Library::OR_Matrix< T >::row_begin(), and Parma_Polyhedra_Library::OR_Matrix< T >::row_end().

                                      {
  dimension_type space;
  if (!(s >> space))
    return false;
  resize_no_copy(space);
  for (row_iterator i = row_begin(),
         this_row_end = row_end(); i != this_row_end; ++i) {
    row_reference_type r_i = *i;
    const dimension_type rs = i.row_size();
    for (dimension_type j = 0; j < rs; ++j) {
      Result r = input(r_i[j], s, ROUND_UP);
      // FIXME: V_CVT_STR_UNK is probably not the only possible error.
      if (!s || r == V_CVT_STR_UNK)
        return false;
    }
  }
  assert(OK());
  return true;
}

template<typename T>

memory_size_type Parma_Polyhedra_Library::OR_Matrix< T >::total_memory_in_bytes

(

)

const [inline]

Returns the total size in bytes of the memory occupied by *this.

Definition at line 430 of file OR_Matrix.inlines.hh.

References Parma_Polyhedra_Library::OR_Matrix< T >::external_memory_in_bytes().

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

template<typename T>

memory_size_type Parma_Polyhedra_Library::OR_Matrix< T >::external_memory_in_bytes

(

)

const [inline]

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

Definition at line 32 of file OR_Matrix.templates.hh.

References Parma_Polyhedra_Library::OR_Matrix< T >::vec.

Referenced by Parma_Polyhedra_Library::OR_Matrix< T >::total_memory_in_bytes().

                                            {
  return vec.external_memory_in_bytes();
}

template<typename T>

bool Parma_Polyhedra_Library::OR_Matrix< T >::OK

(

)

const [inline]

Checks if all the invariants are satisfied.

Definition at line 38 of file OR_Matrix.templates.hh.

References Parma_Polyhedra_Library::OR_Matrix< T >::space_dimension(), Parma_Polyhedra_Library::OR_Matrix< T >::vec, and Parma_Polyhedra_Library::OR_Matrix< T >::vec_capacity.

Referenced by Parma_Polyhedra_Library::OR_Matrix< T >::ascii_load(), and Parma_Polyhedra_Library::OR_Matrix< T >::OR_Matrix().

                       {
#ifndef NDEBUG
  using std::endl;
  using std::cerr;
#endif
  // The right number of cells should be in use.
  const dimension_type dim = space_dimension();
  if (vec.size() != 2*dim*(dim + 1)) {
#ifndef NDEBUG
    cerr << "OR_Matrix has a wrong number of cells:\n"
         << "vec.size() is " << vec.size()
         << ", expected size is " << 2*dim*(dim+1) << "!\n";
#endif
    return false;
  }

  // The underlying DB_Row should be OK.
  if (!vec.OK(vec.size(), vec_capacity))
    return false;

  // All checks passed.
  return true;
}

---

Friends And Related Function Documentation

template<typename T>

friend class OR_Matrix [friend]

Definition at line 361 of file OR_Matrix.defs.hh.

template<typename T>

bool operator==	(	const OR_Matrix< T > &	x,
		const OR_Matrix< T > &	y
	)			[friend]

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

Definition at line 490 of file OR_Matrix.inlines.hh.

                                                         {
  return x.space_dim == y.space_dim && x.vec == y.vec;
}

template<typename T>

std::ostream & operator<<	(	std::ostream &	s,
		const OR_Matrix< T > &	m
	)			[related]

Output operator.

Definition at line 110 of file OR_Matrix.templates.hh.

                                                             {
  for (typename OR_Matrix<T>::const_row_iterator m_iter = m.row_begin(),
         m_end = m.row_end(); m_iter != m_end; ++m_iter) {
    typename OR_Matrix<T>::const_row_reference_type r_m = *m_iter;
    const dimension_type mr_size = m_iter.row_size();
    for (dimension_type j = 0; j < mr_size; ++j)
      s << r_m[j] << " ";
    s << "\n";
  }
  return s;
}

template<typename T>

void swap	(	Parma_Polyhedra_Library::OR_Matrix< T > &	x,
		Parma_Polyhedra_Library::OR_Matrix< T > &	y
	)			[related]

Specializes std::swap.

Definition at line 703 of file OR_Matrix.inlines.hh.

References Parma_Polyhedra_Library::OR_Matrix< T >::swap().

                                             {
  x.swap(y);
}

template<typename T>

bool operator!=	(	const OR_Matrix< T > &	x,
		const OR_Matrix< T > &	y
	)			[related]

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

Definition at line 499 of file OR_Matrix.inlines.hh.

                                                         {
  return !(x == y);
}

template<typename Temp, typename To, typename T>

bool rectilinear_distance_assign	(	Checked_Number< To, Extended_Number_Policy > &	r,
		const OR_Matrix< T > &	x,
		const OR_Matrix< T > &	y,
		Rounding_Dir	dir,
		Temp &	tmp0,
		Temp &	tmp1,
		Temp &	tmp2
	)			[related]

Computes the rectilinear (or Manhattan) distance between x and y.

If the rectilinear distance between x and y is defined, stores an approximation of it into to r and returns true; returns false otherwise.

The direction of the approximation is specified by dir.

All computations are performed using the temporary variables tmp0, tmp1 and tmp2.

Definition at line 641 of file OR_Matrix.inlines.hh.

                                        {
  return
    l_m_distance_assign<Rectilinear_Distance_Specialization<Temp> >(r, x, y,
                                                                    dir,
                                                                    tmp0,
                                                                    tmp1,
                                                                    tmp2);
}

template<typename Temp, typename To, typename T>

bool euclidean_distance_assign	(	Checked_Number< To, Extended_Number_Policy > &	r,
		const OR_Matrix< T > &	x,
		const OR_Matrix< T > &	y,
		Rounding_Dir	dir,
		Temp &	tmp0,
		Temp &	tmp1,
		Temp &	tmp2
	)			[related]

Computes the euclidean distance between x and y.

If the Euclidean distance between x and y is defined, stores an approximation of it into to r and returns true; returns false otherwise.

The direction of the approximation is specified by dir.

All computations are performed using the temporary variables tmp0, tmp1 and tmp2.

Definition at line 661 of file OR_Matrix.inlines.hh.

                                      {
  return
    l_m_distance_assign<Euclidean_Distance_Specialization<Temp> >(r, x, y,
                                                                  dir,
                                                                  tmp0,
                                                                  tmp1,
                                                                  tmp2);
}

template<typename Temp, typename To, typename T>

bool l_infinity_distance_assign	(	Checked_Number< To, Extended_Number_Policy > &	r,
		const OR_Matrix< T > &	x,
		const OR_Matrix< T > &	y,
		Rounding_Dir	dir,
		Temp &	tmp0,
		Temp &	tmp1,
		Temp &	tmp2
	)			[related]

Computes the distance between x and y.

If the distance between x and y is defined, stores an approximation of it into to r and returns true; returns false otherwise.

The direction of the approximation is specified by dir.

All computations are performed using the temporary variables tmp0, tmp1 and tmp2.

Definition at line 681 of file OR_Matrix.inlines.hh.

                                       {
  return
    l_m_distance_assign<L_Infinity_Distance_Specialization<Temp> >(r, x, y,
                                                                   dir,
                                                                   tmp0,
                                                                   tmp1,
                                                                   tmp2);
}

template<typename Specialization, typename Temp, typename To, typename T>

bool l_m_distance_assign	(	Checked_Number< To, Extended_Number_Policy > &	r,
		const OR_Matrix< T > &	x,
		const OR_Matrix< T > &	y,
		const Rounding_Dir	dir,
		Temp &	tmp0,
		Temp &	tmp1,
		Temp &	tmp2
	)			[related]

Definition at line 588 of file OR_Matrix.inlines.hh.

References Parma_Polyhedra_Library::assign_r(), Parma_Polyhedra_Library::combine(), Parma_Polyhedra_Library::OR_Matrix< T >::element_begin(), Parma_Polyhedra_Library::OR_Matrix< T >::element_end(), Parma_Polyhedra_Library::finalize(), Parma_Polyhedra_Library::is_plus_infinity(), Parma_Polyhedra_Library::maybe_assign(), Parma_Polyhedra_Library::OR_Matrix< T >::num_rows(), and PLUS_INFINITY.

                                {
  if (x.num_rows() != y.num_rows())
    return false;
  assign_r(tmp0, 0, ROUND_NOT_NEEDED);
  for (typename OR_Matrix<T>::const_element_iterator
         i = x.element_begin(), j = y.element_begin(),
         mat_end = x.element_end(); i != mat_end; ++i, ++j) {
    const T& x_i = *i;
    const T& y_i = *j;
    if (is_plus_infinity(x_i)) {
      if (is_plus_infinity(y_i))
        continue;
      else {
      pinf:
        assign_r(r, PLUS_INFINITY, ROUND_NOT_NEEDED);
        return true;
      }
    }
    else if (is_plus_infinity(y_i))
      goto pinf;

    const Temp* tmp1p;
    const Temp* tmp2p;
    if (x_i > y_i) {
      maybe_assign(tmp1p, tmp1, x_i, dir);
      maybe_assign(tmp2p, tmp2, y_i, inverse(dir));
    }
    else {
      maybe_assign(tmp1p, tmp1, y_i, dir);
      maybe_assign(tmp2p, tmp2, x_i, inverse(dir));
    }
    sub_assign_r(tmp1, *tmp1p, *tmp2p, dir);
    assert(sgn(tmp1) >= 0);
    Specialization::combine(tmp0, tmp1, dir);
  }

  Specialization::finalize(tmp0, dir);
  assign_r(r, tmp0, dir);
  return true;
}

---

Member Data Documentation

template<typename T>

DB_Row<T> Parma_Polyhedra_Library::OR_Matrix< T >::vec [private]

Contains the rows of the matrix.

A DB_Row which contains the rows of the OR_Matrix inserting each successive row to the end of the vec. To contain all the elements of OR_Matrix the size of the DB_Row is 2*n*(n+1), where the n is the characteristic parameter of OR_Matrix.

Definition at line 371 of file OR_Matrix.defs.hh.

Referenced by Parma_Polyhedra_Library::OR_Matrix< T >::element_begin(), Parma_Polyhedra_Library::OR_Matrix< T >::element_end(), Parma_Polyhedra_Library::OR_Matrix< T >::external_memory_in_bytes(), Parma_Polyhedra_Library::OR_Matrix< T >::grow(), Parma_Polyhedra_Library::OR_Matrix< T >::OK(), Parma_Polyhedra_Library::OR_Matrix< T >::operator=(), Parma_Polyhedra_Library::OR_Matrix< T >::operator[](), Parma_Polyhedra_Library::OR_Matrix< T >::OR_Matrix(), Parma_Polyhedra_Library::OR_Matrix< T >::resize_no_copy(), Parma_Polyhedra_Library::OR_Matrix< T >::row_begin(), Parma_Polyhedra_Library::OR_Matrix< T >::shrink(), and Parma_Polyhedra_Library::OR_Matrix< T >::swap().

template<typename T>

dimension_type Parma_Polyhedra_Library::OR_Matrix< T >::space_dim [private]

Contains the dimension of the space of the matrix.

Definition at line 374 of file OR_Matrix.defs.hh.

Referenced by Parma_Polyhedra_Library::OR_Matrix< T >::grow(), Parma_Polyhedra_Library::OR_Matrix< T >::operator=(), Parma_Polyhedra_Library::OR_Matrix< T >::resize_no_copy(), Parma_Polyhedra_Library::OR_Matrix< T >::shrink(), Parma_Polyhedra_Library::OR_Matrix< T >::space_dimension(), and Parma_Polyhedra_Library::OR_Matrix< T >::swap().

template<typename T>

dimension_type Parma_Polyhedra_Library::OR_Matrix< T >::vec_capacity [private]

Contains the capacity of vec.

Definition at line 377 of file OR_Matrix.defs.hh.

Referenced by Parma_Polyhedra_Library::OR_Matrix< T >::grow(), Parma_Polyhedra_Library::OR_Matrix< T >::OK(), Parma_Polyhedra_Library::OR_Matrix< T >::operator=(), Parma_Polyhedra_Library::OR_Matrix< T >::OR_Matrix(), Parma_Polyhedra_Library::OR_Matrix< T >::resize_no_copy(), and Parma_Polyhedra_Library::OR_Matrix< T >::swap().

---

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

• OR_Matrix.defs.hh
• OR_Matrix.inlines.hh
• OR_Matrix.templates.hh