Parma_Polyhedra_Library::Dense_Row Class Reference

A finite sequence of coefficients. More...

#include <Dense_Row_defs.hh>

Collaboration diagram for Parma_Polyhedra_Library::Dense_Row:

Classes
class	const_iterator
struct	Impl
class	iterator

Public Member Functions
	Dense_Row ()
	Constructs an empty row. More...
	Dense_Row (const Sparse_Row &row)
	Dense_Row (dimension_type sz)
	Tight constructor: resizing may require reallocation. More...
	Dense_Row (dimension_type sz, dimension_type capacity)
	Sizing constructor with capacity. More...
	Dense_Row (const Dense_Row &y)
	Ordinary copy constructor. More...
	Dense_Row (const Dense_Row &y, dimension_type capacity)
	Copy constructor with specified capacity. More...
	Dense_Row (const Dense_Row &y, dimension_type sz, dimension_type capacity)
	Copy constructor with specified size and capacity. More...
	Dense_Row (const Sparse_Row &y, dimension_type sz, dimension_type capacity)
	Copy constructor with specified size and capacity from a Sparse_Row. More...
	~Dense_Row ()
	Destructor. More...
Dense_Row &	operator= (const Dense_Row &y)
	Assignment operator. More...
Dense_Row &	operator= (const Sparse_Row &y)
	Assignment operator. More...
void	m_swap (Dense_Row &y)
	Swaps *this with y. More...
void	resize (dimension_type sz)
	Resizes the row to sz. More...
void	resize (dimension_type sz, dimension_type capacity)
	Resizes the row to sz, with capacity capacity. More...
void	clear ()
	Resets all the elements of this row. More...
void	add_zeroes_and_shift (dimension_type n, dimension_type i)
	Adds n zeroes before index i. More...
void	expand_within_capacity (dimension_type new_size)
	Expands the row to size new_size. More...
void	shrink (dimension_type new_size)
	Shrinks the row by erasing elements at the end. More...
dimension_type	size () const
	Gives the number of coefficients currently in use. More...
void	normalize ()
	Normalizes the modulo of coefficients so that they are mutually prime. More...
void	swap_coefficients (dimension_type i, dimension_type j)
void	swap_coefficients (iterator i, iterator j)
iterator	begin ()
const_iterator	begin () const
iterator	end ()
const_iterator	end () const
void	reset (dimension_type i)
void	reset (dimension_type first, dimension_type last)
iterator	reset (iterator itr)
Coefficient_traits::const_reference	get (dimension_type i) const
iterator	find (dimension_type i)
	Provided for compatibility with Sparse_Row. More...
const_iterator	find (dimension_type i) const
	Provided for compatibility with Sparse_Row. More...
iterator	find (iterator itr, dimension_type i)
	Provided for compatibility with Sparse_Row. More...
const_iterator	find (const_iterator itr, dimension_type i) const
	Provided for compatibility with Sparse_Row. More...
iterator	lower_bound (dimension_type i)
	Provided for compatibility with Sparse_Row. More...
const_iterator	lower_bound (dimension_type i) const
	Provided for compatibility with Sparse_Row. More...
iterator	lower_bound (iterator itr, dimension_type i)
	Provided for compatibility with Sparse_Row. More...
const_iterator	lower_bound (const_iterator itr, dimension_type i) const
	Provided for compatibility with Sparse_Row. More...
iterator	insert (dimension_type i, Coefficient_traits::const_reference x)
	Provided for compatibility with Sparse_Row. More...
iterator	insert (dimension_type i)
	Provided for compatibility with Sparse_Row. More...
iterator	insert (iterator itr, dimension_type i, Coefficient_traits::const_reference x)
	Provided for compatibility with Sparse_Row. More...
iterator	insert (iterator itr, dimension_type i)
	Provided for compatibility with Sparse_Row. More...
template<typename Func1 , typename Func2 >
void	combine_needs_first (const Dense_Row &y, const Func1 &f, const Func2 &g)
	Calls g(x[i],y[i]), for each i. More...
template<typename Func1 , typename Func2 >
void	combine_needs_second (const Dense_Row &y, const Func1 &g, const Func2 &h)
	Calls g(x[i],y[i]), for each i. More...
template<typename Func1 , typename Func2 , typename Func3 >
void	combine (const Dense_Row &y, const Func1 &f, const Func2 &g, const Func3 &h)
	Calls g(x[i],y[i]), for each i. More...
void	linear_combine (const Dense_Row &y, Coefficient_traits::const_reference coeff1, Coefficient_traits::const_reference coeff2)
void	linear_combine (const Dense_Row &y, Coefficient_traits::const_reference c1, Coefficient_traits::const_reference c2, dimension_type start, dimension_type end)
void	ascii_dump () const
	Writes to std::cerr an ASCII representation of *this. More...
void	ascii_dump (std::ostream &s) const
	Writes to s an ASCII representation of *this. More...
void	print () const
	Prints *this to std::cerr using operator<<. More...
bool	ascii_load (std::istream &s)
	Loads from s an ASCII representation (as produced by ascii_dump(std::ostream&) const) and sets *this accordingly. Returns true if successful, false otherwise. More...
memory_size_type	total_memory_in_bytes () const
	Returns a lower bound to the total size in bytes of the memory occupied by *this. More...
memory_size_type	external_memory_in_bytes () const
	Returns a lower bound to the size in bytes of the memory managed by *this. More...
memory_size_type	total_memory_in_bytes (dimension_type capacity) const
	Returns the total size in bytes of the memory occupied by *this, provided the capacity of *this is given by capacity. More...
memory_size_type	external_memory_in_bytes (dimension_type capacity) const
	Returns the size in bytes of the memory managed by *this, provided the capacity of *this is given by capacity. More...
bool	OK () const
	Checks if all the invariants are satisfied. More...
bool	OK (dimension_type row_size) const
	Checks if all the invariants are satisfied and that the actual size matches the value provided as argument. More...
Subscript operators
Coefficient &	operator[] (dimension_type k)
	Returns a reference to the element of the row indexed by k. More...
Coefficient_traits::const_reference	operator[] (dimension_type k) const
	Returns a constant reference to the element of the row indexed by k. More...

Static Public Member Functions
static dimension_type	max_size ()
	Returns the size() of the largest possible Dense_Row. More...

Private Member Functions
void	init (const Sparse_Row &row)
void	destroy ()
dimension_type	capacity () const
	Returns the capacity of the row. More...

Private Attributes
Impl	impl

Related Functions
(Note that these are not member functions.)
bool	operator== (const Dense_Row &x, const Dense_Row &y)
void	swap (Dense_Row &x, Dense_Row &y)
	Swaps x with y. More...
void	iter_swap (std::vector< Dense_Row >::iterator x, std::vector< Dense_Row >::iterator y)
	Swaps objects referred by x and y. More...
bool	operator== (const Dense_Row &x, const Dense_Row &y)
	Returns true if and only if x and y are equal. More...
bool	operator!= (const Dense_Row &x, const Dense_Row &y)
	Returns true if and only if x and y are different. More...
void	linear_combine (Dense_Row &x, const Dense_Row &y, Coefficient_traits::const_reference coeff1, Coefficient_traits::const_reference coeff2)
void	linear_combine (Dense_Row &x, const Dense_Row &y, Coefficient_traits::const_reference c1, Coefficient_traits::const_reference c2, dimension_type start, dimension_type end)
bool	operator!= (const Dense_Row &x, const Dense_Row &y)
void	swap (Dense_Row &x, Dense_Row &y)
void	iter_swap (std::vector< Dense_Row >::iterator x, std::vector< Dense_Row >::iterator y)

Detailed Description

A finite sequence of coefficients.

Definition at line 42 of file Dense_Row_defs.hh.

Constructor & Destructor Documentation

Parma_Polyhedra_Library::Dense_Row::Dense_Row ( )

inline

Constructs an empty row.

Definition at line 64 of file Dense_Row_inlines.hh.

References OK().

  : impl() {

  PPL_ASSERT(OK());
}

Parma_Polyhedra_Library::Dense_Row::Dense_Row ( const Sparse_Row &  row )

explicit

Definition at line 240 of file Dense_Row.cc.

References init(), OK(), Parma_Polyhedra_Library::Sparse_Row::size(), and size().

  : impl() {

  init(row);

  PPL_ASSERT(size() == row.size());
  PPL_ASSERT(OK());
}

Parma_Polyhedra_Library::Dense_Row::Dense_Row ( dimension_type  sz )

inline

Tight constructor: resizing may require reallocation.

Constructs a row with size and capacity sz.

Definition at line 83 of file Dense_Row_inlines.hh.

References OK(), resize(), and size().

  : impl() {

  resize(sz);

  PPL_ASSERT(size() == sz);
  PPL_ASSERT(OK());
}

Parma_Polyhedra_Library::Dense_Row::Dense_Row ( dimension_type  sz, dimension_type  capacity  )

inline

Sizing constructor with capacity.

Parameters

sz	The size of the row that will be constructed;
capacity	The capacity of the row that will be constructed;

The row that is constructed has storage for capacity elements, sz of which are default-constructed now.

Definition at line 71 of file Dense_Row_inlines.hh.

References Parma_Polyhedra_Library::Dense_Row::Impl::capacity, impl, OK(), resize(), and size().

  : impl() {

  resize(sz, capacity);

  PPL_ASSERT(size() == sz);
  PPL_ASSERT(impl.capacity == capacity);
  PPL_ASSERT(OK());
}

Parma_Polyhedra_Library::Dense_Row::Dense_Row ( const Dense_Row &  y )

inline

Ordinary copy constructor.

Definition at line 93 of file Dense_Row_inlines.hh.

References Parma_Polyhedra_Library::Dense_Row::Impl::capacity, capacity(), Parma_Polyhedra_Library::Dense_Row::Impl::coeff_allocator, impl, OK(), size(), Parma_Polyhedra_Library::Dense_Row::Impl::size, and Parma_Polyhedra_Library::Dense_Row::Impl::vec.

  : impl() {
  impl.coeff_allocator = y.impl.coeff_allocator;
  if (y.impl.vec != 0) {
    impl.capacity = y.capacity();
    impl.vec = impl.coeff_allocator.allocate(impl.capacity);
    while (impl.size != y.size()) {
      new(&impl.vec[impl.size]) Coefficient(y[impl.size]);
      ++impl.size;
    }
  }
  PPL_ASSERT(size() == y.size());
  PPL_ASSERT(capacity() == y.capacity());
  PPL_ASSERT(OK());
}

Parma_Polyhedra_Library::Dense_Row::Dense_Row ( const Dense_Row &  y, dimension_type  capacity  )

inline

Copy constructor with specified capacity.

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

Definition at line 110 of file Dense_Row_inlines.hh.

References Parma_Polyhedra_Library::Dense_Row::Impl::capacity, capacity(), Parma_Polyhedra_Library::Dense_Row::Impl::coeff_allocator, impl, max_size(), OK(), size(), Parma_Polyhedra_Library::Dense_Row::Impl::size, and Parma_Polyhedra_Library::Dense_Row::Impl::vec.

  : impl() {
  PPL_ASSERT(y.size() <= capacity);
  PPL_ASSERT(capacity <= max_size());

  impl.capacity = capacity;
  impl.coeff_allocator = y.impl.coeff_allocator;
  impl.vec = impl.coeff_allocator.allocate(impl.capacity);

  if (y.impl.vec != 0) {
    while (impl.size != y.size()) {
      new(&impl.vec[impl.size]) Coefficient(y[impl.size]);
      ++impl.size;
    }
  }

  PPL_ASSERT(size() == y.size());
  PPL_ASSERT(impl.capacity == capacity);
  PPL_ASSERT(OK());
}

Parma_Polyhedra_Library::Dense_Row::Dense_Row ( const Dense_Row &  y, dimension_type  sz, dimension_type  capacity  )

inline

Copy constructor with specified size and capacity.

It is assumed that sz is less than or equal to capacity.

Definition at line 133 of file Dense_Row_inlines.hh.

References Parma_Polyhedra_Library::Dense_Row::Impl::capacity, capacity(), Parma_Polyhedra_Library::Dense_Row::Impl::coeff_allocator, impl, max_size(), OK(), size(), Parma_Polyhedra_Library::Dense_Row::Impl::size, and Parma_Polyhedra_Library::Dense_Row::Impl::vec.

  : impl() {
  PPL_ASSERT(sz <= capacity);
  PPL_ASSERT(capacity <= max_size());
  PPL_ASSERT(capacity != 0);

  impl.capacity = capacity;
  impl.coeff_allocator = y.impl.coeff_allocator;
  impl.vec = impl.coeff_allocator.allocate(impl.capacity);

  const dimension_type n = std::min(sz, y.size());
  while (impl.size != n) {
    new(&impl.vec[impl.size]) Coefficient(y[impl.size]);
    ++impl.size;
  }
  while (impl.size != sz) {
    new(&impl.vec[impl.size]) Coefficient();
    ++impl.size;
  }

  PPL_ASSERT(size() == sz);
  PPL_ASSERT(impl.capacity == capacity);
  PPL_ASSERT(OK());
}

Parma_Polyhedra_Library::Dense_Row::Dense_Row	(	const Sparse_Row &	y,
		dimension_type	sz,
		dimension_type	capacity
	)

Copy constructor with specified size and capacity from a Sparse_Row.

It is assumed that sz is less than or equal to capacity.

Definition at line 34 of file Dense_Row.cc.

References Parma_Polyhedra_Library::Sparse_Row::begin(), Parma_Polyhedra_Library::Sparse_Row::lower_bound(), OK(), resize(), and Parma_Polyhedra_Library::Sparse_Row::size().

                                                                      {
  resize(sz, capacity);
  for (Sparse_Row::const_iterator i = y.begin(),
         i_end = y.lower_bound(std::min(y.size(), sz)); i != i_end; ++i) {
    (*this)[i.index()] = *i;
  }
  PPL_ASSERT(OK());
}

Parma_Polyhedra_Library::Dense_Row::~Dense_Row ( )

inline

Destructor.

Definition at line 161 of file Dense_Row_inlines.hh.

                      {
  // The `impl' field will be destroyed automatically.
}

Member Function Documentation

void Parma_Polyhedra_Library::Dense_Row::add_zeroes_and_shift	(	dimension_type	n,
		dimension_type	i
	)

Adds n zeroes before index i.

Parameters

n	The number of zeroes that will be added to the row.
i	The index of the element before which the zeroes will be added.

Existing elements with index greater than or equal to i are shifted to the right by n positions. The size is increased by n.

Existing iterators are invalidated.

Definition at line 140 of file Dense_Row.cc.

References Parma_Polyhedra_Library::Dense_Row::Impl::capacity, Parma_Polyhedra_Library::Dense_Row::Impl::coeff_allocator, Parma_Polyhedra_Library::compute_capacity(), impl, Parma_Polyhedra_Library::swap(), and Parma_Polyhedra_Library::Dense_Row::Impl::vec.

                                                                     {
  PPL_ASSERT(i <= size());
  const dimension_type new_size = size() + n;
  if (new_size > capacity()) {
    Dense_Row new_row;
    const dimension_type new_capacity = compute_capacity(new_size, max_size());
    // This may throw.
    new_row.impl.vec = new_row.impl.coeff_allocator.allocate(new_capacity);
    new_row.impl.capacity = new_capacity;

    dimension_type j = i;
    try {
      // Construct coefficients with value 0 in
      // new_row.impl.vec[i ... i + n - 1]
      for ( ; j < i + n; ++j) {
        new(&(new_row.impl.vec[j])) Coefficient(0);
      }
    } catch (...) {
      // Destroy the zeroes constructed so far.
      while (j != i) {
        --j;
        new_row.impl.vec[j].~Coefficient();
      }
      // The new_row's destructor will de-allocate the memory.
      throw;
    }

    // Raw-copy the coefficients.
    memcpy(new_row.impl.vec, impl.vec, sizeof(Coefficient) * i);
    memcpy(&(new_row.impl.vec[i + n]), &impl.vec[i],
           sizeof(Coefficient) * (impl.size - i));

    using std::swap;
    swap(impl.vec, new_row.impl.vec);
    swap(impl.capacity, new_row.impl.capacity);

    // *this now owns all coefficients, including the newly-added zeroes.
    impl.size = new_size;

    // The old vec will be de-allocated at the end of this block.

  }
  else {
    memmove(&impl.vec[n + i], &impl.vec[i], sizeof(Coefficient)
            * (impl.size - i));
    impl.size = i;
    const dimension_type target_size = impl.size + n;
    PPL_ASSERT(target_size == i + n);
    try {
      // Construct n zeroes where the moved elements resided.
      while (impl.size != target_size) {
        new(&impl.vec[impl.size]) Coefficient(0);
        ++impl.size;
      }
      impl.size = new_size;
    } catch (...) {
      // impl.vec[impl.size]..impl.vec[target_size-1] are still unconstructed,
      // but impl.vec[target_size]..impl.vec[new_size] are constructed,
      // because the memmove() moved already-constructed objects.

      // NOTE: This loop can't throw, because destructors must not throw.
      for (dimension_type j = target_size; j < new_size; ++j) {
        impl.vec[j].~Coefficient();
      }

      throw;
    }
  }

  PPL_ASSERT(OK());
}

void Parma_Polyhedra_Library::Dense_Row::ascii_dump

(

)

const

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

void Parma_Polyhedra_Library::Dense_Row::ascii_dump

(

std::ostream &

s

)

const

Writes to s an ASCII representation of *this.

Definition at line 479 of file Dense_Row.cc.

References size().

                                            {
  const Dense_Row& x = *this;
  const dimension_type x_size = x.size();
  s << "size " << x_size << " ";
  for (dimension_type i = 0; i < x_size; ++i) {
    s << x[i] << ' ';
  }
  s << "\n";
}

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

Definition at line 492 of file Dense_Row.cc.

                                      {
  std::string str;
  if (!(s >> str) || str != "size") {
    return false;
  }
  dimension_type new_size;
  if (!(s >> new_size)) {
    return false;
  }

  resize(new_size);

  for (dimension_type col = 0; col < new_size; ++col) {
    if (!(s >> (*this)[col])) {
      return false;
    }
  }

  return true;
}

Dense_Row::iterator Parma_Polyhedra_Library::Dense_Row::begin ( )

inline

Definition at line 238 of file Dense_Row_inlines.hh.

                 {
  return iterator(*this, 0);
}

Dense_Row::const_iterator Parma_Polyhedra_Library::Dense_Row::begin ( ) const

inline

Definition at line 243 of file Dense_Row_inlines.hh.

                       {
  return const_iterator(*this, 0);
}

dimension_type Parma_Polyhedra_Library::Dense_Row::capacity ( ) const

inlineprivate

Returns the capacity of the row.

Definition at line 59 of file Dense_Row_inlines.hh.

References Parma_Polyhedra_Library::Dense_Row::Impl::capacity, and impl.

Referenced by Dense_Row(), and Parma_Polyhedra_Library::Dense_Row::Impl::~Impl().

                          {
  return impl.capacity;
}

void Parma_Polyhedra_Library::Dense_Row::clear

(

)

Resets all the elements of this row.

Definition at line 133 of file Dense_Row.cc.

                    {
  for (iterator i = begin(), i_end = end(); i != i_end; ++i) {
    *i = 0;
  }
}

template<typename Func1 , typename Func2 , typename Func3 >

void Parma_Polyhedra_Library::Dense_Row::combine	(	const Dense_Row &	y,
		const Func1 &	f,
		const Func2 &	g,
		const Func3 &	h
	)

Calls g(x[i],y[i]), for each i.

Parameters

y	The row that will be combined with *this.
f	A functor that should take a Coefficient&. f(c1) must be equivalent to g(c1, 0).
g	A functor that should take a Coefficient& and a Coefficient_traits::const_reference. g(c1, c2) must do nothing when both c1 and c2 are zero.
h	A functor that should take a Coefficient& and a Coefficient_traits::const_reference. h(c1, c2) must be equivalent to g(c1, c2) when c1 is zero.

This method takes time.

Note

The functors will only be called when necessary, assuming the requested properties hold.

See also

combine_needs_first

combine_needs_second

Definition at line 50 of file Dense_Row_templates.hh.

References size().

                                   {
  for (dimension_type i = size(); i-- > 0; ) {
    g((*this)[i], y[i]);
  }
}

template<typename Func1 , typename Func2 >

void Parma_Polyhedra_Library::Dense_Row::combine_needs_first	(	const Dense_Row &	y,
		const Func1 &	f,
		const Func2 &	g
	)

Calls g(x[i],y[i]), for each i.

Parameters

y	The row that will be combined with *this.
f	A functor that should take a Coefficient&. f(c1) must be equivalent to g(c1, 0).
g	A functor that should take a Coefficient& and a Coefficient_traits::const_reference. g(c1, c2) must do nothing when c1 is zero.

This method takes time.

Note

The functors will only be called when necessary, assuming the requested properties hold.

See also

combine_needs_second

combine

Definition at line 32 of file Dense_Row_templates.hh.

References size().

                                               {
  for (dimension_type i = size(); i-- > 0; ) {
    g((*this)[i], y[i]);
  }
}

template<typename Func1 , typename Func2 >

void Parma_Polyhedra_Library::Dense_Row::combine_needs_second	(	const Dense_Row &	y,
		const Func1 &	g,
		const Func2 &	h
	)

Calls g(x[i],y[i]), for each i.

Parameters

y	The row that will be combined with *this.
g	A functor that should take a Coefficient& and a Coefficient_traits::const_reference. g(c1, 0) must do nothing, for every c1.
h	A functor that should take a Coefficient& and a Coefficient_traits::const_reference. h(c1, c2) must be equivalent to g(c1, c2) when c1 is zero.

This method takes time.

Note

The functors will only be called when necessary, assuming the requested properties hold.

See also

combine_needs_first

combine

Definition at line 41 of file Dense_Row_templates.hh.

References size().

                                                {
  for (dimension_type i = size(); i-- > 0; ) {
    g((*this)[i], y[i]);
  }
}

void Parma_Polyhedra_Library::Dense_Row::destroy ( )

inlineprivate

Definition at line 166 of file Dense_Row_inlines.hh.

References Parma_Polyhedra_Library::Dense_Row::Impl::capacity, Parma_Polyhedra_Library::Dense_Row::Impl::coeff_allocator, impl, resize(), and Parma_Polyhedra_Library::Dense_Row::Impl::vec.

                   {
  resize(0);
  impl.coeff_allocator.deallocate(impl.vec, impl.capacity);
}

Dense_Row::iterator Parma_Polyhedra_Library::Dense_Row::end ( )

inline

Definition at line 248 of file Dense_Row_inlines.hh.

References size().

               {
  return iterator(*this, size());
}

Dense_Row::const_iterator Parma_Polyhedra_Library::Dense_Row::end ( ) const

inline

Definition at line 253 of file Dense_Row_inlines.hh.

References size().

                     {
  return const_iterator(*this, size());
}

void Parma_Polyhedra_Library::Dense_Row::expand_within_capacity

(

dimension_type

new_size

)

Expands the row to size new_size.

Adds new positions to the implementation of the row obtaining a new row with size new_size. It is assumed that new_size is between the current size and capacity of the row.

Definition at line 213 of file Dense_Row.cc.

                                                                  {
  PPL_ASSERT(new_size <= impl.capacity);
  PPL_ASSERT(size() <= new_size && new_size <= max_size());
  while (impl.size != new_size) {
    new(&impl.vec[impl.size]) Coefficient();
    ++impl.size;
  }
  PPL_ASSERT(size() == new_size);
  PPL_ASSERT(OK());
}

PPL::memory_size_type Parma_Polyhedra_Library::Dense_Row::external_memory_in_bytes

(

)

const

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

Definition at line 519 of file Dense_Row.cc.

References Parma_Polyhedra_Library::external_memory_in_bytes().

Referenced by total_memory_in_bytes().

                                             {
  memory_size_type n = impl.capacity * sizeof(Coefficient);
  for (dimension_type i = size(); i-- > 0; ) {
    n += PPL::external_memory_in_bytes(impl.vec[i]);
  }
  return n;
}

PPL::memory_size_type Parma_Polyhedra_Library::Dense_Row::external_memory_in_bytes

(

dimension_type

capacity

)

const

Returns the size in bytes of the memory managed by *this, provided the capacity of *this is given by capacity.

Definition at line 514 of file Dense_Row.cc.

References Parma_Polyhedra_Library::external_memory_in_bytes().

                                                             {
  return external_memory_in_bytes();
}

Dense_Row::iterator Parma_Polyhedra_Library::Dense_Row::find ( dimension_type  i )

inline

Provided for compatibility with Sparse_Row.

Definition at line 263 of file Dense_Row_inlines.hh.

Referenced by insert(), and lower_bound().

                                {
  return iterator(*this, i);
}

Dense_Row::const_iterator Parma_Polyhedra_Library::Dense_Row::find ( dimension_type  i ) const

inline

Provided for compatibility with Sparse_Row.

Definition at line 268 of file Dense_Row_inlines.hh.

                                      {
  return const_iterator(*this, i);
}

Dense_Row::iterator Parma_Polyhedra_Library::Dense_Row::find ( iterator  itr, dimension_type  i  )

inline

Provided for compatibility with Sparse_Row.

Definition at line 273 of file Dense_Row_inlines.hh.

                                              {
  (void)itr;
  return iterator(*this, i);
}

Dense_Row::const_iterator Parma_Polyhedra_Library::Dense_Row::find ( const_iterator  itr, dimension_type  i  ) const

inline

Provided for compatibility with Sparse_Row.

Definition at line 279 of file Dense_Row_inlines.hh.

                                                          {
  (void)itr;
  return const_iterator(*this, i);
}

Coefficient_traits::const_reference Parma_Polyhedra_Library::Dense_Row::get ( dimension_type  i ) const

inline

Gets the i-th element. Provided for compatibility with Sparse_Row.

Definition at line 258 of file Dense_Row_inlines.hh.

Referenced by Parma_Polyhedra_Library::MIP_Problem::linear_combine().

                                     {
  return (*this)[i];
}

void Parma_Polyhedra_Library::Dense_Row::init ( const Sparse_Row &  row )

private

Definition at line 250 of file Dense_Row.cc.

References Parma_Polyhedra_Library::Sparse_Row::begin(), Parma_Polyhedra_Library::Sparse_Row::end(), Parma_Polyhedra_Library::CO_Tree::const_iterator::index(), and Parma_Polyhedra_Library::Sparse_Row::size().

Referenced by Dense_Row().

                                        {
  impl.capacity = row.size();
  impl.vec = impl.coeff_allocator.allocate(impl.capacity);
  Sparse_Row::const_iterator itr = row.begin();
  Sparse_Row::const_iterator itr_end = row.end();
  while (impl.size != impl.capacity) {
    // Constructs (*this)[impl.size] with row[impl.size].
    if (itr != itr_end && itr.index() == impl.size) {
      new(&impl.vec[impl.size]) Coefficient(*itr);
      ++itr;
    }
    else {
      new(&impl.vec[impl.size]) Coefficient();
    }
    ++impl.size;
  }
  PPL_ASSERT(size() == row.size());
  PPL_ASSERT(OK());
}

Dense_Row::iterator Parma_Polyhedra_Library::Dense_Row::insert ( dimension_type  i, Coefficient_traits::const_reference  x  )

inline

Provided for compatibility with Sparse_Row.

Definition at line 305 of file Dense_Row_inlines.hh.

References find().

                                                       {
  (*this)[i] = x;
  return find(i);
}

Dense_Row::iterator Parma_Polyhedra_Library::Dense_Row::insert ( dimension_type  i )

inline

Provided for compatibility with Sparse_Row.

Definition at line 312 of file Dense_Row_inlines.hh.

References find().

                                  {
  return find(i);
}

Dense_Row::iterator Parma_Polyhedra_Library::Dense_Row::insert ( iterator  itr, dimension_type  i, Coefficient_traits::const_reference  x  )

inline

Provided for compatibility with Sparse_Row.

Definition at line 317 of file Dense_Row_inlines.hh.

References find().

                                                       {
  (void)itr;
  (*this)[i] = x;
  return find(i);
}

Dense_Row::iterator Parma_Polyhedra_Library::Dense_Row::insert ( iterator  itr, dimension_type  i  )

inline

Provided for compatibility with Sparse_Row.

Definition at line 325 of file Dense_Row_inlines.hh.

References find().

                                                {
  (void)itr;
  return find(i);
}

void Parma_Polyhedra_Library::Dense_Row::linear_combine	(	const Dense_Row &	y,
		Coefficient_traits::const_reference	coeff1,
		Coefficient_traits::const_reference	coeff2
	)

Executes (*this)[i] = (*this)[i]*coeff1 + y[i]*coeff2, for each i.

Parameters

y	The row that will be combined with *this.
coeff1	The coefficient used for elements of *this. It must not be 0.
coeff2	The coefficient used for elements of y. It must not be 0.

This method takes time.

See also

combine_needs_first

combine_needs_second

combine

Definition at line 389 of file Dense_Row.cc.

References linear_combine(), and size().

Referenced by linear_combine(), and Parma_Polyhedra_Library::linear_combine().

                                                                         {
  Dense_Row& x = *this;
  PPL_ASSERT(x.size() == y.size());

  x.linear_combine(y, coeff1, coeff2, 0, x.size());
}

void Parma_Polyhedra_Library::Dense_Row::linear_combine	(	const Dense_Row &	y,
		Coefficient_traits::const_reference	c1,
		Coefficient_traits::const_reference	c2,
		dimension_type	start,
		dimension_type	end
	)

Equivalent to (*this)[i] = (*this)[i] * c1 + y[i] * c2, for each i in [start, end).

This method detects when coeff1==1 and/or coeff2==1 or coeff2==-1 in order to save some work.

coeff1 and coeff2 must not be 0.

Definition at line 399 of file Dense_Row.cc.

References Parma_Polyhedra_Library::add_mul_assign(), and size().

                                                                         {
  Dense_Row& x = *this;
  PPL_ASSERT(start <= end);
  PPL_ASSERT(end <= x.size());
  PPL_ASSERT(end <= y.size());
  PPL_ASSERT(coeff1 != 0);
  PPL_ASSERT(coeff2 != 0);

  // If coeff1 is 1 and/or coeff2 is 1 or -1, we use an optimized
  // implementation.

  if (coeff1 == 1) {
    if (coeff2 == 1) {
      // Optimized implementation for coeff1==1, coeff2==1.
      for (dimension_type i = start; i < end; ++i) {
        if (y[i] != 0) {
          x[i] += y[i];
        }
      }
      return;
    }
    if (coeff2 == -1) {
      // Optimized implementation for coeff1==1, coeff2==-1.
      for (dimension_type i = start; i < end; ++i) {
        if (y[i] != 0) {
          x[i] -= y[i];
        }
      }
      return;
    }
    // Optimized implementation for coeff1==1.
    for (dimension_type i = start; i < end; ++i) {
      Coefficient& x_i = x[i];
      // The test against 0 gives rise to a consistent speed up: see
      // http://www.cs.unipr.it/pipermail/ppl-devel/2009-February/014000.html
      Coefficient_traits::const_reference y_i = y[i];
      if (y_i != 0) {
        add_mul_assign(x_i, y_i, coeff2);
      }
    }
    return;
  }

  if (coeff2 == 1) {
    // Optimized implementation for coeff2==1.
    for (dimension_type i = start; i < end; ++i) {
      x[i] *= coeff1;
      if (y[i] != 0) {
        x[i] += y[i];
      }
    }
    return;
  }
  if (coeff2 == -1) {
    // Optimized implementation for coeff2==-1.
    for (dimension_type i = start; i < end; ++i) {
      x[i] *= coeff1;
      if (y[i] != 0) {
        x[i] -= y[i];
      }
    }
    return;
  }
  // General case.
  for (dimension_type i = start; i < end; ++i) {
    Coefficient& x_i = x[i];
    x[i] *= coeff1;
    // The test against 0 gives rise to a consistent speed up: see
    // http://www.cs.unipr.it/pipermail/ppl-devel/2009-February/014000.html
    Coefficient_traits::const_reference y_i = y[i];
    if (y_i != 0) {
      add_mul_assign(x_i, y_i, coeff2);
    }
  }
}

Dense_Row::iterator Parma_Polyhedra_Library::Dense_Row::lower_bound ( dimension_type  i )

inline

Provided for compatibility with Sparse_Row.

Definition at line 285 of file Dense_Row_inlines.hh.

References find().

                                       {
  return find(i);
}

Dense_Row::const_iterator Parma_Polyhedra_Library::Dense_Row::lower_bound ( dimension_type  i ) const

inline

Provided for compatibility with Sparse_Row.

Definition at line 290 of file Dense_Row_inlines.hh.

References find().

                                             {
  return find(i);
}

Dense_Row::iterator Parma_Polyhedra_Library::Dense_Row::lower_bound ( iterator  itr, dimension_type  i  )

inline

Provided for compatibility with Sparse_Row.

Definition at line 295 of file Dense_Row_inlines.hh.

References find().

                                                     {
  return find(itr, i);
}

Dense_Row::const_iterator Parma_Polyhedra_Library::Dense_Row::lower_bound ( const_iterator  itr, dimension_type  i  ) const

inline

Provided for compatibility with Sparse_Row.

Definition at line 300 of file Dense_Row_inlines.hh.

References find().

                                                                 {
  return find(itr, i);
}

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

inline

Swaps *this with y.

Definition at line 172 of file Dense_Row_inlines.hh.

References Parma_Polyhedra_Library::Dense_Row::Impl::capacity, Parma_Polyhedra_Library::Dense_Row::Impl::coeff_allocator, impl, OK(), Parma_Polyhedra_Library::Dense_Row::Impl::size, swap(), Parma_Polyhedra_Library::swap(), and Parma_Polyhedra_Library::Dense_Row::Impl::vec.

Referenced by swap().

                              {
  using std::swap;
  swap(impl.size, y.impl.size);
  swap(impl.capacity, y.impl.capacity);
  swap(impl.coeff_allocator, y.impl.coeff_allocator);
  swap(impl.vec, y.impl.vec);
  PPL_ASSERT(OK());
  PPL_ASSERT(y.OK());
}

dimension_type Parma_Polyhedra_Library::Dense_Row::max_size ( )

inlinestatic

Returns the size() of the largest possible Dense_Row.

Definition at line 49 of file Dense_Row_inlines.hh.

Referenced by Dense_Row(), and Parma_Polyhedra_Library::Linear_Expression::max_space_dimension().

                    {
  return std::numeric_limits<size_t>::max() / sizeof(Coefficient);
}

void Parma_Polyhedra_Library::Dense_Row::normalize

(

)

Normalizes the modulo of coefficients so that they are mutually prime.

Computes the Greatest Common Divisor (GCD) among the elements of the row and normalizes them by the GCD itself.

Definition at line 329 of file Dense_Row.cc.

References Parma_Polyhedra_Library::exact_div_assign(), Parma_Polyhedra_Library::gcd_assign(), Parma_Polyhedra_Library::neg_assign(), PPL_DIRTY_TEMP_COEFFICIENT, and Parma_Polyhedra_Library::Boundary_NS::sgn().

Referenced by Parma_Polyhedra_Library::MIP_Problem::linear_combine().

                        {
  Dense_Row& x = *this;
  // Compute the GCD of all the coefficients.
  const dimension_type sz = size();
  dimension_type i = sz;
  PPL_DIRTY_TEMP_COEFFICIENT(gcd);
  while (i > 0) {
    Coefficient_traits::const_reference x_i = x[--i];
    if (const int x_i_sign = sgn(x_i)) {
      gcd = x_i;
      if (x_i_sign < 0) {
        neg_assign(gcd);
      }
      goto compute_gcd;
    }
  }
  // We reach this point only if all the coefficients were zero.
  return;

compute_gcd:
  if (gcd == 1) {
    return;
  }
  while (i > 0) {
    Coefficient_traits::const_reference x_i = x[--i];
    if (x_i != 0) {
      // Note: we use the ternary version instead of a more concise
      // gcd_assign(gcd, x_i) to take advantage of the fact that
      // `gcd' will decrease very rapidly (see D. Knuth, The Art of
      // Computer Programming, second edition, Section 4.5.2,
      // Algorithm C, and the discussion following it).  Our
      // implementation of gcd_assign(x, y, z) for checked numbers is
      // optimized for the case where `z' is smaller than `y', so that
      // on checked numbers we gain.  On the other hand, for the
      // implementation of gcd_assign(x, y, z) on GMP's unbounded
      // integers we cannot make any assumption, so here we draw.
      // Overall, we win.
      gcd_assign(gcd, x_i, gcd);
      if (gcd == 1) {
        return;
      }
    }
  }
  // Divide the coefficients by the GCD.
  for (dimension_type j = sz; j-- > 0; ) {
    Coefficient& x_j = x[j];
    exact_div_assign(x_j, x_j, gcd);
  }
}

bool Parma_Polyhedra_Library::Dense_Row::OK

(

)

const

Checks if all the invariants are satisfied.

Definition at line 528 of file Dense_Row.cc.

Referenced by Dense_Row(), m_swap(), Parma_Polyhedra_Library::Dense_Row::iterator::operator++(), Parma_Polyhedra_Library::Dense_Row::const_iterator::operator++(), Parma_Polyhedra_Library::Dense_Row::iterator::operator--(), and Parma_Polyhedra_Library::Dense_Row::const_iterator::operator--().

                       {
#ifndef NDEBUG
  using std::endl;
  using std::cerr;
#endif

  bool is_broken = false;

  if (impl.capacity > max_size()) {
#ifndef NDEBUG
    cerr << "Dense_Row capacity exceeds the maximum allowed size:" << endl
         << "is " << impl.capacity
         << ", should be less than or equal to " << max_size() << "."
         << endl;
#endif
    is_broken = true;
  }

  if (size() > max_size()) {
#ifndef NDEBUG
    cerr << "Dense_Row size exceeds the maximum allowed size:" << endl
         << "is " << size()
         << ", should be less than or equal to " << max_size() << "." << endl;
#endif
    is_broken = true;
  }

  if (impl.capacity < size()) {
#ifndef NDEBUG
    cerr << "Dense_Row is completely broken: capacity is " << impl.capacity
         << ", size is " << size() << "." << endl;
#endif
    is_broken = true;
  }

  if (capacity() == 0) {
    if (impl.vec != 0) {
      is_broken = true;
    }
  }
  else {
    if (impl.vec == 0) {
      is_broken = true;
    }
  }

  return !is_broken;
}

bool Parma_Polyhedra_Library::Dense_Row::OK

(

dimension_type

row_size

)

const

Checks if all the invariants are satisfied and that the actual size matches the value provided as argument.

Definition at line 578 of file Dense_Row.cc.

                                                    {
#ifndef NDEBUG
  using std::endl;
  using std::cerr;
#endif

  bool is_broken = !OK();

  // Check the declared size.
  if (size() != row_size) {
#ifndef NDEBUG
    cerr << "Dense_Row size mismatch: is " << size()
         << ", should be " << row_size << "." << endl;
#endif
    is_broken = true;
  }
  return !is_broken;
}

Dense_Row & Parma_Polyhedra_Library::Dense_Row::operator= ( const Dense_Row &  y )

inline

Assignment operator.

Definition at line 183 of file Dense_Row_inlines.hh.

References size(), and swap().

                                       {

  if (this != &y && size() == y.size()) {
    // Avoid reallocation.

    for (dimension_type i = size(); i-- > 0; ) {
      (*this)[i] = y[i];
    }

    return *this;
  }

  Dense_Row x(y);
  swap(*this, x);

  return *this;
}

PPL::Dense_Row & Parma_Polyhedra_Library::Dense_Row::operator=

(

const Sparse_Row &

y

)

Assignment operator.

Definition at line 271 of file Dense_Row.cc.

References Parma_Polyhedra_Library::Sparse_Row::begin(), Parma_Polyhedra_Library::Coefficient_zero(), Parma_Polyhedra_Library::Sparse_Row::end(), Parma_Polyhedra_Library::CO_Tree::const_iterator::index(), and Parma_Polyhedra_Library::Sparse_Row::size().

                                             {
  if (size() > row.size()) {
    // TODO: If the shrink() is modified to reallocate a smaller chunk,
    // this can be optimized.
    shrink(row.size());
    Sparse_Row::const_iterator itr = row.begin();
    Sparse_Row::const_iterator itr_end = row.end();
    for (dimension_type i = 0; i < impl.size; ++i) {
      // Computes (*this)[impl.size] = row[impl.size].
      if (itr != itr_end && itr.index() == i) {
        impl.vec[impl.size] = *itr;
        ++itr;
      }
      else {
        impl.vec[impl.size] = Coefficient_zero();
      }
    }
  }
  else {
    if (capacity() >= row.size()) {
      // size() <= row.size() <= capacity().
      Sparse_Row::const_iterator itr = row.begin();
      Sparse_Row::const_iterator itr_end = row.end();
      for (dimension_type i = 0; i < impl.size; ++i) {
        // The following code is equivalent to (*this)[i] = row[i].
        if (itr != itr_end && itr.index() == impl.size) {
          new(&impl.vec[impl.size]) Coefficient(*itr);
          ++itr;
        }
        else {
          new(&impl.vec[impl.size]) Coefficient();
        }
      }
      // Construct the additional elements.
      for ( ; impl.size != row.size(); ++impl.size) {
        // Constructs (*this)[impl.size] with row[impl.size].
        if (itr != itr_end && itr.index() == impl.size) {
          new(&impl.vec[impl.size]) Coefficient(*itr);
          ++itr;
        }
        else {
          new(&impl.vec[impl.size]) Coefficient();
        }
      }
    }
    else {
      // Reallocation is required.
      destroy();
      init(row);
    }
  }
  PPL_ASSERT(size() == row.size());
  PPL_ASSERT(OK());

  return *this;
}

Coefficient & Parma_Polyhedra_Library::Dense_Row::operator[] ( dimension_type  k )

inline

Returns a reference to the element of the row indexed by k.

Definition at line 202 of file Dense_Row_inlines.hh.

References impl, size(), and Parma_Polyhedra_Library::Dense_Row::Impl::vec.

                                            {
  PPL_ASSERT(impl.vec != 0);
  PPL_ASSERT(k < size());
  return impl.vec[k];
}

Coefficient_traits::const_reference Parma_Polyhedra_Library::Dense_Row::operator[] ( dimension_type  k ) const

inline

Returns a constant reference to the element of the row indexed by k.

Definition at line 209 of file Dense_Row_inlines.hh.

References impl, size(), and Parma_Polyhedra_Library::Dense_Row::Impl::vec.

                                                  {
  PPL_ASSERT(impl.vec != 0);
  PPL_ASSERT(k < size());
  return impl.vec[k];
}

void Parma_Polyhedra_Library::Dense_Row::print

(

)

const

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

void Parma_Polyhedra_Library::Dense_Row::reset ( dimension_type  i )

inline

Resets the i-th element to 0. Provided for compatibility with Sparse_Row

Definition at line 226 of file Dense_Row_inlines.hh.

Referenced by Parma_Polyhedra_Library::Expression_Hide_Inhomo< T >::get_row().

                                 {
  (*this)[i] = 0;
}

void Parma_Polyhedra_Library::Dense_Row::reset	(	dimension_type	first,
		dimension_type	last
	)

Resets the elements [first,last) to 0. Provided for compatibility with Sparse_Row

Definition at line 380 of file Dense_Row.cc.

                                                             {
  PPL_ASSERT(first <= last);
  PPL_ASSERT(last <= size());
  for (dimension_type i = first; i < last; ++i) {
    (*this)[i] = 0;
  }
}

Dense_Row::iterator Parma_Polyhedra_Library::Dense_Row::reset ( iterator  itr )

inline

Resets the element pointed to by itr to 0. Provided for compatibility with Sparse_Row.

Definition at line 231 of file Dense_Row_inlines.hh.

                             {
  *itr = 0;
  ++itr;
  return itr;
}

void Parma_Polyhedra_Library::Dense_Row::resize

(

dimension_type

sz

)

Resizes the row to sz.

Definition at line 45 of file Dense_Row.cc.

Referenced by Dense_Row(), destroy(), and Parma_Polyhedra_Library::Expression_Hide_Last< T >::get_row().

                                            {
  if (new_size <= size()) {
    shrink(new_size);
  }
  else {
    if (new_size > capacity()) {
      // Reallocation is required.
      // TODO: Consider using realloc() here.
      // TODO: Consider using a smarter allocation strategy.
      const dimension_type new_capacity = new_size;
      Coefficient* const new_vec = impl.coeff_allocator.allocate(new_capacity);

      if (impl.vec != 0) {
        memcpy(new_vec, impl.vec, sizeof(Coefficient) * impl.size);
        impl.coeff_allocator.deallocate(impl.vec, impl.capacity);
      }

      impl.vec = new_vec;
      impl.capacity = new_capacity;
    }
    PPL_ASSERT(new_size <= impl.capacity);
    // Construct the additional elements.
    while (impl.size != new_size) {
      new(&impl.vec[impl.size]) Coefficient();
      ++impl.size;
    }
  }
  PPL_ASSERT(size() == new_size);
  PPL_ASSERT(OK());
}

void Parma_Polyhedra_Library::Dense_Row::resize	(	dimension_type	sz,
		dimension_type	capacity
	)

Resizes the row to sz, with capacity capacity.

Definition at line 77 of file Dense_Row.cc.

                                                                         {
  PPL_ASSERT(new_size <= new_capacity);

  if (new_capacity == 0) {
    destroy();
    impl.vec = 0;
    impl.size = 0;
    impl.capacity = 0;

    PPL_ASSERT(size() == new_size);
    PPL_ASSERT(capacity() == new_capacity);
    PPL_ASSERT(OK());

    return;
  }

  if (new_capacity < capacity()) {

    shrink(new_size);

    PPL_ASSERT(impl.size == new_size);

    Coefficient* const new_vec = impl.coeff_allocator.allocate(new_capacity);

    PPL_ASSERT(impl.vec != 0);

    memcpy(new_vec, impl.vec, sizeof(Coefficient) * impl.size);

    impl.coeff_allocator.deallocate(impl.vec, impl.capacity);

    impl.vec = new_vec;
    impl.capacity = new_capacity;
  }
  else {
    if (new_capacity > capacity()) {

      Coefficient* const new_vec = impl.coeff_allocator.allocate(new_capacity);

      if (impl.vec != 0) {
        memcpy(new_vec, impl.vec, sizeof(Coefficient) * impl.size);
        impl.coeff_allocator.deallocate(impl.vec, impl.capacity);
      }

      impl.vec = new_vec;
      impl.capacity = new_capacity;

      resize(new_size);
    }
  }

  PPL_ASSERT(size() == new_size);
  PPL_ASSERT(capacity() == new_capacity);
  PPL_ASSERT(OK());
}

void Parma_Polyhedra_Library::Dense_Row::shrink

(

dimension_type

new_size

)

Shrinks the row by erasing elements at the end.

Destroys elements of the row implementation from position new_size to the end. It is assumed that new_size is not greater than the current size.

Definition at line 225 of file Dense_Row.cc.

                                            {
  PPL_ASSERT(new_size <= size());
  // Since ~Coefficient() does not throw exceptions, nothing here does.

  // We assume construction was done "forward".
  // We thus perform destruction "backward".
  while (impl.size != new_size) {
    --impl.size;
    impl.vec[impl.size].~Coefficient();
  }

  PPL_ASSERT(size() == new_size);
  PPL_ASSERT(OK());
}

dimension_type Parma_Polyhedra_Library::Dense_Row::size ( ) const

inline

Gives the number of coefficients currently in use.

Definition at line 54 of file Dense_Row_inlines.hh.

References impl, and Parma_Polyhedra_Library::Dense_Row::Impl::size.

Referenced by ascii_dump(), combine(), combine_needs_first(), combine_needs_second(), Dense_Row(), end(), Parma_Polyhedra_Library::Expression_Hide_Last< T >::get_row(), Parma_Polyhedra_Library::Linear_Expression_Impl< Row >::have_a_common_variable(), linear_combine(), Parma_Polyhedra_Library::MIP_Problem::linear_combine(), Parma_Polyhedra_Library::Dense_Row::iterator::OK(), Parma_Polyhedra_Library::Dense_Row::const_iterator::OK(), Parma_Polyhedra_Library::Dense_Row::iterator::operator*(), Parma_Polyhedra_Library::Dense_Row::const_iterator::operator*(), Parma_Polyhedra_Library::Dense_Row::iterator::operator++(), Parma_Polyhedra_Library::Dense_Row::const_iterator::operator++(), operator=(), operator==(), Parma_Polyhedra_Library::operator==(), operator[](), and Parma_Polyhedra_Library::Dense_Row::Impl::~Impl().

                      {
  return impl.size;
}

void Parma_Polyhedra_Library::Dense_Row::swap_coefficients ( dimension_type  i, dimension_type  j  )

inline

Swaps the i-th element with the j-th element. Provided for compatibility with Sparse_Row

Definition at line 216 of file Dense_Row_inlines.hh.

References Parma_Polyhedra_Library::swap().

                                                               {
  std::swap((*this)[i], (*this)[j]);
}

void Parma_Polyhedra_Library::Dense_Row::swap_coefficients ( iterator  i, iterator  j  )

inline

Swaps the element pointed to by i with the element pointed to by j. Provided for compatibility with Sparse_Row

Definition at line 221 of file Dense_Row_inlines.hh.

References Parma_Polyhedra_Library::swap().

                                                   {
  std::swap(*i, *j);
}

memory_size_type Parma_Polyhedra_Library::Dense_Row::total_memory_in_bytes ( ) const

inline

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

Definition at line 331 of file Dense_Row_inlines.hh.

References external_memory_in_bytes().

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

memory_size_type Parma_Polyhedra_Library::Dense_Row::total_memory_in_bytes ( dimension_type  capacity ) const

inline

Returns the total size in bytes of the memory occupied by *this, provided the capacity of *this is given by capacity.

Definition at line 336 of file Dense_Row_inlines.hh.

References external_memory_in_bytes().

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

Friends And Related Function Documentation

void iter_swap ( std::vector< Dense_Row >::iterator  x, std::vector< Dense_Row >::iterator  y  )

related

Swaps objects referred by x and y.

void iter_swap ( std::vector< Dense_Row >::iterator  x, std::vector< Dense_Row >::iterator  y  )

related

Definition at line 527 of file Dense_Row_inlines.hh.

References swap().

                                          {
  swap(*x, *y);
}

void linear_combine ( Dense_Row &  x, const Dense_Row &  y, Coefficient_traits::const_reference  coeff1, Coefficient_traits::const_reference  coeff2  )

related

Definition at line 505 of file Dense_Row_inlines.hh.

                                                         {
  x.linear_combine(y, coeff1, coeff2);
}

void linear_combine ( Dense_Row &  x, const Dense_Row &  y, Coefficient_traits::const_reference  c1, Coefficient_traits::const_reference  c2, dimension_type  start, dimension_type  end  )

related

Equivalent to x[i] = x[i] * c1 + y[i] * c2, for each i in [start, end).

Definition at line 512 of file Dense_Row_inlines.hh.

                                                         {
  x.linear_combine(y, c1, c2, start, end);
}

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

related

Definition at line 342 of file Dense_Row_inlines.hh.

                                                   {
  return !(x == y);
}

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

related

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

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

related

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

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

related

Definition at line 599 of file Dense_Row.cc.

References size().

                                                      {
  const dimension_type x_size = x.size();
  const dimension_type y_size = y.size();

  if (x_size != y_size) {
    return false;
  }

  for (dimension_type i = x_size; i-- > 0; ) {
    if (x[i] != y[i]) {
      return false;
    }
  }

  return true;
}

void swap ( Dense_Row &  x, Dense_Row &  y  )

related

Swaps x with y.

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

void swap ( Dense_Row &  x, Dense_Row &  y  )

related

Definition at line 521 of file Dense_Row_inlines.hh.

References m_swap().

                                 {
  x.m_swap(y);
}

Member Data Documentation

Impl Parma_Polyhedra_Library::Dense_Row::impl

private

Definition at line 426 of file Dense_Row_defs.hh.

Referenced by add_zeroes_and_shift(), capacity(), Dense_Row(), destroy(), m_swap(), operator[](), and size().

---

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

• Dense_Row_defs.hh
• Dense_Row.cc
• Dense_Row_inlines.hh
• Dense_Row_templates.hh