synaps/upol/rep.h

#ifndef SYNAPS_UPOL_UPAR_H
#define SYNAPS_UPOL_UPAR_H
//-----------------------------------------------------------------------
#include <cassert>
#include <synaps/init.h>
#include <synaps/base/type.h>
#include <synaps/linalg/rep1d.h>
//-----------------------------------------------------------------------

__BEGIN_NAMESPACE_SYNAPS


template<class I,class V, class N> struct upol_iterator;
//-----------------------------------------------------------------------
//OPEN
namespace upol {
  using namespace type; // for AsSize
template <class C>
struct rep : public linalg::rep1d<C> {

  typedef C coeff_t;
  typedef typename linalg::rep1d<C>::size_type size_type;
  typedef typename linalg::rep1d<C>::iterator iterator;
  typedef typename linalg::rep1d<C>::const_iterator const_iterator;
  typedef typename linalg::rep1d<C>::const_reverse_iterator const_reverse_iterator;
  typedef typename linalg::rep1d<C>::reverse_iterator reverse_iterator;

  int degree_;

  rep(): linalg::rep1d<C>(), degree_(-1) {}
  rep(size_type s, AsSize): linalg::rep1d<C>(s), degree_(s-1) {}
  rep(size_type s, C *t): linalg::rep1d<C>(s,t), degree_(s-1)
    {checkdegree(*this);}
  rep(C* b, C *e): linalg::rep1d<C>(b,e)
    {degree_=this->size_-1;checkdegree(*this);}
  rep(const rep<C> & p): linalg::rep1d<C>(p), degree_(p.degree_)
    {}//{cout <<"copy rep"<<endl;}

  void resize(size_type n)
    {this->linalg::rep1d<C>::resize(n); degree_=n-1;}

  iterator          end()         { return iterator(this->tab_+degree_+1); }
  const_iterator    end()   const { return const_iterator(this->tab_+degree_+1); }

  reverse_iterator       rbegin()
    {return reverse_iterator(this->tab_+degree_+1); }
  const_reverse_iterator rbegin() const
    {return const_reverse_iterator(this->tab_+degree_+1); }

  rep<C> & operator=(const rep<C> & v)
    {this->linalg::rep1d<C>::operator=(v); degree_=v.degree_; return *this;}

};
//-------------------------------------------------------------------------
template <class C> inline
int checkdegree(rep<C> & a)
{
  int l = a.degree_;
  while(l >=0 && (a.tab_[l]==0)) {l--;}
  a.degree_=l;
  return a.degree_;
}
//-------------------------------------------------------------------------
template <class C>
void assign(rep<C> & a, const rep<C> & b)
{
  assign((linalg::rep1d<C> &)a,(const linalg::rep1d<C> &)b);
  a.degree_ = b.degree_;
}
//-------------------------------------------------------------------------
template<class I, class V, class N>
struct upol_iterator
{
public:
  typedef upol_iterator<I,V,N> self_t;

  upol_iterator<I,V,N>(): my_ptr(), my_idx(0)            {}
  upol_iterator(V* t): my_ptr(t), my_idx(0)        {}
  upol_iterator(V* t, int n): my_ptr(t), my_idx(n) {}
  upol_iterator(const upol_iterator<I,V,N> & t):
    my_ptr(t.my_ptr), my_idx(t.my_idx) {}

  self_t&
  operator++()  {my_ptr++; my_idx++; return *this;}

  self_t&
  operator--()  {my_ptr--; my_idx--; return *this;}

  V   operator*() const {return *my_ptr;}
  V & operator*()       {return *my_ptr;}

  int index()   {return my_idx;}

  bool operator!=( self_t const& rhs) { return my_ptr != rhs.my_ptr; }
  bool operator<=( self_t const& rhs) { return my_ptr <= rhs.my_ptr; }

private:
  I  my_ptr;
  N  my_idx;
};
//-------------------------------------------------------------------------
}//CLOSE upol
//-------------------------------------------------------------------------
__END_NAMESPACE_SYNAPS
//-------------------------------------------------------------------------
#endif // SYNAPS_UPOL_UPAR_H