mmx::Seq< C, R > Struct Template Reference

Sequence of terms with reference counter. More...

#include <Seq.hpp>

Public Types
typedef R::size_type	size_type
typedef C	value_type
typedef C	value_t
typedef R::iterator	iterator
typedef R::const_iterator	const_iterator
typedef R::reverse_iterator	reverse_iterator
typedef R::const_reverse_iterator	const_reverse_iterator
typedef Seq< C, R >	self_t

Public Member Functions
R &	rep ()
const R &	rep () const
	Seq ()
	Seq (const R &r)
	Seq (size_type s)
	Seq (size_type s, value_type *t)
	Seq (iterator b, iterator e)
	Seq (size_type m, const char *str)
	Seq (char *str)
	Seq (const self_t &r)
template<class X , class S >
	Seq (const Seq< X, S > &P)
iterator	begin ()
iterator	end ()
const_iterator	begin () const
const_iterator	end () const
reverse_iterator	rbegin ()
reverse_iterator	rend ()
const_reverse_iterator	rbegin () const
const_reverse_iterator	rend () const
self_t &	operator= (const self_t &V)
template<class X , class S >
self_t &	operator= (const Seq< X, S > &V)
value_type &	operator[] (size_type i)
const value_type &	operator[] (size_type i) const
const value_type &	front () const
self_t &	push_back (const C &x)
self_t &	erase (size_type i)
self_t &	clear ()
size_type	search (const C &x)
bool	member (const C &x)
void	sort ()
void	insert (const size_type &i, const C &c)
C	min ()
C	max ()
template<class Compare >
void	sort (Compare comp)
template<class Compare >
C	min (Compare comp)
template<class Compare >
C	max (Compare comp)
size_type	size () const
bool	empty () const
void	resize (size_type i)
C	back () const
void	pop_back ()
void	reverse ()
	Reverse list. More...
self_t	reversed () const
self_t	operator, (const self_t &x) const
	Concatenate two sequences. More...
self_t	operator, (const C &x) const
	Concatenate an element at the end of the sequence. More...
self_t	operator<< (const self_t &s)
	~Seq ()

Public Attributes
shared_object< R >	data

Detailed Description

template<class C, class R = std::vector<C>>
struct mmx::Seq< C, R >

Sequence of terms with reference counter.

It allows to use it as output of other functions. The container R should have the following signatures:

typename R::size_type;
typename R::iterator;
typename R::const_iterator;
typename R::reverse_iterator;
typename R::const_reverse_iterator;

      C begin();
      C end();

      C rbegin();
      C rend();

      C& operator[] (size_type);
const C& operator[] (size_type) const;

Examples:

polynomial_mv_sparse_test.cpp, polynomial_mv_test.cpp, solver_mv_bernstein_binary_test.cpp, solver_mv_bernstein_proj_test.cpp, solver_mv_fatarcs_test.cpp, solver_mv_monomial_test.cpp, solver_uv_bernstein_binary_test.cpp, solver_uv_contfrac_extended_test.cpp, solver_uv_inewton_test.cpp, and solver_uv_test.cpp.

Member Typedef Documentation

template<class C, class R = std::vector<C>>

typedef R::const_iterator mmx::Seq< C, R >::const_iterator

template<class C, class R = std::vector<C>>

typedef R::const_reverse_iterator mmx::Seq< C, R >::const_reverse_iterator

template<class C, class R = std::vector<C>>

typedef R::iterator mmx::Seq< C, R >::iterator

template<class C, class R = std::vector<C>>

typedef R::reverse_iterator mmx::Seq< C, R >::reverse_iterator

template<class C, class R = std::vector<C>>

typedef Seq<C,R> mmx::Seq< C, R >::self_t

template<class C, class R = std::vector<C>>

typedef R::size_type mmx::Seq< C, R >::size_type

template<class C, class R = std::vector<C>>

typedef C mmx::Seq< C, R >::value_t

template<class C, class R = std::vector<C>>

typedef C mmx::Seq< C, R >::value_type

Constructor & Destructor Documentation

template<class C, class R = std::vector<C>>

mmx::Seq< C, R >::Seq ( )

inline

template<class C, class R = std::vector<C>>

mmx::Seq< C, R >::Seq ( const R &  r )

inline

template<class C, class R = std::vector<C>>

mmx::Seq< C, R >::Seq ( size_type  s )

inline

template<class C, class R = std::vector<C>>

mmx::Seq< C, R >::Seq ( size_type  s, value_type *  t  )

inline

template<class C, class R = std::vector<C>>

mmx::Seq< C, R >::Seq ( iterator  b, iterator  e  )

inline

template<class C, class R = std::vector<C>>

mmx::Seq< C, R >::Seq	(	size_type	m,
		const char *	str
	)

template<class C , class R>

mmx::Seq< C, R >::Seq

(

char *

str

)

template<class C, class R = std::vector<C>>

mmx::Seq< C, R >::Seq ( const self_t &  r )

inline

template<class C, class R = std::vector<C>>

template<class X , class S >

mmx::Seq< C, R >::Seq ( const Seq< X, S > &  P )

inline

template<class C, class R = std::vector<C>>

mmx::Seq< C, R >::~Seq ( )

inline

Member Function Documentation

template<class C, class R = std::vector<C>>

C mmx::Seq< C, R >::back ( ) const

inline

template<class C, class R = std::vector<C>>

iterator mmx::Seq< C, R >::begin ( )

inline

template<class C, class R = std::vector<C>>

const_iterator mmx::Seq< C, R >::begin ( ) const

inline

template<class C, class R = std::vector<C>>

self_t& mmx::Seq< C, R >::clear ( )

inline

template<class C, class R = std::vector<C>>

bool mmx::Seq< C, R >::empty ( ) const

inline

template<class C, class R = std::vector<C>>

iterator mmx::Seq< C, R >::end ( )

inline

template<class C, class R = std::vector<C>>

const_iterator mmx::Seq< C, R >::end ( ) const

inline

template<class C, class R = std::vector<C>>

self_t& mmx::Seq< C, R >::erase ( size_type  i )

inline

template<class C, class R = std::vector<C>>

const value_type& mmx::Seq< C, R >::front ( ) const

inline

template<class C, class R = std::vector<C>>

void mmx::Seq< C, R >::insert ( const size_type &  i, const C &  c  )

inline

template<class C, class R = std::vector<C>>

C mmx::Seq< C, R >::max ( )

inline

template<class C, class R = std::vector<C>>

template<class Compare >

C mmx::Seq< C, R >::max ( Compare  comp )

inline

template<class C, class R = std::vector<C>>

bool mmx::Seq< C, R >::member ( const C &  x )

inline

template<class C, class R = std::vector<C>>

C mmx::Seq< C, R >::min ( )

inline

template<class C, class R = std::vector<C>>

template<class Compare >

C mmx::Seq< C, R >::min ( Compare  comp )

inline

template<class C, class R = std::vector<C>>

self_t mmx::Seq< C, R >::operator,

(

const self_t &

x

)

const

Concatenate two sequences.

template<class C, class R >

Seq< C, R > mmx::Seq< C, R >::operator,

(

const C &

x

)

const

Concatenate an element at the end of the sequence.

template<class C, class R = std::vector<C>>

self_t mmx::Seq< C, R >::operator<< ( const self_t &  s )

inline

template<class C, class R = std::vector<C>>

self_t& mmx::Seq< C, R >::operator= ( const self_t &  V )

inline

template<class C, class R = std::vector<C>>

template<class X , class S >

self_t& mmx::Seq< C, R >::operator= ( const Seq< X, S > &  V )

inline

template<class C, class R = std::vector<C>>

value_type& mmx::Seq< C, R >::operator[] ( size_type  i )

inline

template<class C, class R = std::vector<C>>

const value_type& mmx::Seq< C, R >::operator[] ( size_type  i ) const

inline

template<class C, class R = std::vector<C>>

void mmx::Seq< C, R >::pop_back ( )

inline

template<class C, class R = std::vector<C>>

self_t& mmx::Seq< C, R >::push_back ( const C &  x )

inline

template<class C, class R = std::vector<C>>

reverse_iterator mmx::Seq< C, R >::rbegin ( )

inline

template<class C, class R = std::vector<C>>

const_reverse_iterator mmx::Seq< C, R >::rbegin ( ) const

inline

template<class C, class R = std::vector<C>>

reverse_iterator mmx::Seq< C, R >::rend ( )

inline

template<class C, class R = std::vector<C>>

const_reverse_iterator mmx::Seq< C, R >::rend ( ) const

inline

template<class C, class R = std::vector<C>>

R& mmx::Seq< C, R >::rep ( )

inline

template<class C, class R = std::vector<C>>

const R& mmx::Seq< C, R >::rep ( ) const

inline

template<class C, class R = std::vector<C>>

void mmx::Seq< C, R >::resize ( size_type  i )

inline

template<class C, class R = std::vector<C>>

void mmx::Seq< C, R >::reverse ( )

inline

Reverse list.

template<class C, class R = std::vector<C>>

self_t mmx::Seq< C, R >::reversed ( ) const

inline

template<class C, class R = std::vector<C>>

size_type mmx::Seq< C, R >::search ( const C &  x )

inline

template<class C, class R = std::vector<C>>

size_type mmx::Seq< C, R >::size ( void  ) const

inline

Examples:

solver_mv_fatarcs_test.cpp.

template<class C, class R = std::vector<C>>

void mmx::Seq< C, R >::sort ( )

inline

template<class C, class R = std::vector<C>>

template<class Compare >

void mmx::Seq< C, R >::sort ( Compare  comp )

inline

Member Data Documentation

template<class C, class R = std::vector<C>>

shared_object<R> mmx::Seq< C, R >::data

---

The documentation for this struct was generated from the following file:

• include/realroot/Seq.hpp