00001 #ifndef SYNAPS_UPOL_UPAR_H
00002 #define SYNAPS_UPOL_UPAR_H
00003
00004 #include <cassert>
00005 #include <synaps/init.h>
00006 #include <synaps/base/type.h>
00007 #include <synaps/linalg/rep1d.h>
00008
00009
00010 __BEGIN_NAMESPACE_SYNAPS
00011
00012
00013 template<class I,class V, class N> struct upol_iterator;
00014
00015
00016 namespace upol {
00017 using namespace type;
00022 template <class C>
00023 struct rep : public linalg::rep1d<C> {
00024
00025 typedef C coeff_t;
00026 typedef typename linalg::rep1d<C>::size_type size_type;
00027 typedef typename linalg::rep1d<C>::iterator iterator;
00028 typedef typename linalg::rep1d<C>::const_iterator const_iterator;
00029 typedef typename linalg::rep1d<C>::const_reverse_iterator const_reverse_iterator;
00030 typedef typename linalg::rep1d<C>::reverse_iterator reverse_iterator;
00031
00032 int degree_;
00033
00034 rep(): linalg::rep1d<C>(), degree_(-1) {}
00035 rep(size_type s, AsSize): linalg::rep1d<C>(s), degree_(s-1) {}
00036 rep(size_type s, C *t): linalg::rep1d<C>(s,t), degree_(s-1)
00037 {checkdegree(*this);}
00038 rep(C* b, C *e): linalg::rep1d<C>(b,e)
00039 {degree_=this->size_-1;checkdegree(*this);}
00040 rep(const rep<C> & p): linalg::rep1d<C>(p), degree_(p.degree_)
00041 {}
00042
00043 void resize(size_type n)
00044 {this->linalg::rep1d<C>::resize(n); degree_=n-1;}
00045
00046 iterator end() { return iterator(this->tab_+degree_+1); }
00047 const_iterator end() const { return const_iterator(this->tab_+degree_+1); }
00048
00049 reverse_iterator rbegin()
00050 {return reverse_iterator(this->tab_+degree_+1); }
00051 const_reverse_iterator rbegin() const
00052 {return const_reverse_iterator(this->tab_+degree_+1); }
00053
00054 rep<C> & operator=(const rep<C> & v)
00055 {this->linalg::rep1d<C>::operator=(v); degree_=v.degree_; return *this;}
00056
00057 };
00058
00059 template <class C> inline
00060 int checkdegree(rep<C> & a)
00061 {
00062 int l = a.degree_;
00063 while(l >=0 && (a.tab_[l]==0)) {l--;}
00064 a.degree_=l;
00065 return a.degree_;
00066 }
00067
00068 template <class C>
00069 void assign(rep<C> & a, const rep<C> & b)
00070 {
00071 assign((linalg::rep1d<C> &)a,(const linalg::rep1d<C> &)b);
00072 a.degree_ = b.degree_;
00073 }
00074
00075 template<class I, class V, class N>
00076 struct upol_iterator
00077 {
00078 public:
00079 typedef upol_iterator<I,V,N> self_t;
00080
00081 upol_iterator<I,V,N>(): my_ptr(), my_idx(0) {}
00082 upol_iterator(V* t): my_ptr(t), my_idx(0) {}
00083 upol_iterator(V* t, int n): my_ptr(t), my_idx(n) {}
00084 upol_iterator(const upol_iterator<I,V,N> & t):
00085 my_ptr(t.my_ptr), my_idx(t.my_idx) {}
00086
00087 self_t&
00088 operator++() {my_ptr++; my_idx++; return *this;}
00089
00090 self_t&
00091 operator--() {my_ptr--; my_idx--; return *this;}
00092
00093 V operator*() const {return *my_ptr;}
00094 V & operator*() {return *my_ptr;}
00095
00096 int index() {return my_idx;}
00097
00098 bool operator!=( self_t const& rhs) { return my_ptr != rhs.my_ptr; }
00099 bool operator<=( self_t const& rhs) { return my_ptr <= rhs.my_ptr; }
00100
00101 private:
00102 I my_ptr;
00103 N my_idx;
00104 };
00105
00106 }
00107
00108 __END_NAMESPACE_SYNAPS
00109
00110 #endif // SYNAPS_UPOL_UPAR_H
00111