synaps/mpol/dynamicexp.h

/*********************************************************************
*      This file is part of the source code of SYNAPS kernel.        *
*   Author(s): B. Mourrain, GALAAD, INRIA                            *
**********************************************************************
$Id: dynamicexp.h,v 1.1 2005/07/11 11:17:56 mourrain Exp $
**********************************************************************/
#ifndef synaps_mpol_dynamicexp_h_
#define synaps_mpol_dynamicexp_h_

#include <stdlib.h>
#include <iostream>
#include <string>
#include <iterator>
#include <cassert>
#include <synaps/init.h>
#include <synaps/arithm/REF.h>
#include <synaps/base/COUNT.h>
#include <synaps/linalg/VECTOR.m>


__BEGIN_NAMESPACE_SYNAPS

template<class E=unsigned>
struct dynamicexp {

  typedef E            value_type;
  typedef unsigned int size_type;
  typedef E*           iterator;
  typedef iterator     const_iterator;
  typedef std::reverse_iterator<const_iterator>  const_reverse_iterator;
  typedef std::reverse_iterator<iterator>        reverse_iterator;

  typedef E   exponent_t;
  typedef int degree_t;
  typedef dynamicexp<E> self_t;

  // constructors
  dynamicexp():_size(0),_tab(NULL){}
  dynamicexp(const dynamicexp<E> & d):_size(d._size){
        //    cout <<"Copy "<<d<<" ";
        if (_size) {
          _tab = dynamicexp<E>::alloc(_size);
          memcpy(_tab,d._tab,sizeof(E)*_size);
        }
        else
          _tab = NULL;
        //    cout <<*this<<endl;
  }

  dynamicexp(int s): _size(s){
        //    cout <<"C "<<s<<endl;
        _tab = dynamicexp<E>::alloc(s);
        for(int i=0;i<s;i++) _tab[i]=(exponent_t)0;
        //    cout <<*this<<endl;
  }

  dynamicexp(int s, E *t): _size(s){
        assert(s <= sizeof(t)/sizeof(E));
        _tab = dynamicexp<E>::alloc(_size);
        for(int i=0;i<s;i++) _tab[i]=t[i];
  }

  template<class S>
        self_t & operator =(const VAL<S> & M)
        {
          if (this == &(M.rep())) { return *this; }
          assign(*this,M.rep());
          return *this;
        }

  // destructor
  ~dynamicexp(){if (_tab) delete [] _tab;}

  size_type size() const {return _size;}

  iterator        begin()       {return iterator(_tab); }
  const_iterator  begin() const {return const_iterator(_tab); }
  iterator        end()         {return iterator(_tab+_size); }
  const_iterator  end()   const {return const_iterator(_tab+_size); }

  reverse_iterator       rbegin()       {return reverse_iterator(_tab+_size); }
  const_reverse_iterator rbegin() const {return reverse_iterator(_tab+_size); }
  reverse_iterator       rend()         {return reverse_iterator(_tab); }
  const_reverse_iterator rend()   const {return reverse_iterator(_tab); }

  E   operator[] ( size_type i) const {
        //    if(i<0) cout <<"("<<*this<<"["<<i<<"])";
    return (i<_size?_tab[i]:0); 
  }
  E & operator[] (size_type i) { assert(i<_size);return _tab[i];}

  // affectation operator
  self_t& operator = (const self_t & A) {
        if (&A == this) { return *this; }
        if (_tab != NULL) {
          // cout << "sz = " << sizeof( _tab) << " " << _size << endl;
          // for (int kk = 0; kk < _size; ++kk) {
          //   cout << _tab[kk] << " ";
          // } cout << endl;
          delete [] _tab;
        }
        _size = A._size;
        if (_size) {
          _tab = dynamicexp<E>::alloc(_size);
          memcpy(_tab,A._tab,sizeof(E)*_size);
        }
        else
          _tab = NULL;
        return *this;
  }

  //  self_t & operator+= (const self_t & B);

  void reserve(size_type s)
  {
        if (!s) {
          if (_size) { delete [] _tab; }
          _size = 0;
          _tab = NULL;
        }
        else if(_tab==NULL) {
          _size = s;_tab = dynamicexp<E>::alloc(s);
          //for(size_type i=0;i<s;i++) _tab[i]=(exponent_t)0;
        }
        else {
          delete [] _tab;
          _tab = dynamicexp<E>::alloc(s);
          _size=s;
        }
  }
  void resize(size_type s)
  {
        if(s<=_size)
          _size = s;
        else{
          E* _tmp =_tab;
          _tab = dynamicexp<E>::alloc(s);
          for(size_type i =0;i<_size;i++) _tab[i]=_tmp[i];
          for(size_type i =_size;i<s;i++) _tab[i]=0;
          delete [] _tmp;
          _size=s;
        }
  }


  void init(int s)
  {
        if (_size) { delete [] _tab; }
        _size= s;
        _tab = dynamicexp<E>::alloc(s);
  }

  self_t& setExponent(size_type i, value_type d);

  friend bool operator == (const dynamicexp & A, const dynamicexp & B) {
        int i,minsize=std::min(A._size,B._size);
        for(i=0;i<minsize;i++)
          if(A._tab[i]!=B._tab[i]) return 0;
        if(A._size>B._size)
        {
          for(;i<(int)A._size;i++)
                if(A._tab[i]) return 0;
        }
        else
        {
          for(;i<(int)B._size;i++)
                if(B._tab[i]) return 0;

        }
        //        if (A._size == B._size)
        //     return memcmp(A._tab,B._tab,sizeof(E)*A._size) == 0;
        return 1;
  }
  friend bool operator != (const dynamicexp & A, const dynamicexp & B) {
        return !(A==B);
  }
  // Data
  size_type _size;
  E*        _tab;

  static E* alloc(unsigned int N)
  {return (new E[N]);}
  //{return (E *)malloc(sizeof(E)*N);}
  void clear() {delete[] _tab;}
  //{free(_tab); }

};
//----------------------------------------------------------------------
  template<class E> inline
typename dynamicexp<E>::degree_t degree(const dynamicexp<E> & t)
{
  typename dynamicexp<E>::degree_t d(0);
  for (typename dynamicexp<E>::size_type i = 0; i < t._size; ++i) d+=t[i];
  return(d);
}
//----------------------------------------------------------------------
template<class E>
std::ostream & operator << (std::ostream & os, const dynamicexp<E> & t) {
  bool first=true;
  if(t._size)
        for (typename dynamicexp<E>::size_type i = 0; i < t._size; ++i)
        {
          if (t[i] == 1){
                if(first) first=false; else os <<"*";
                os <<'X'<< i;
          }else if (t[i] == 0);
          else {
                if(first) first=false; else os <<"*";
                os <<"X"<< i << '^' <<(int)(t[i]);
          }
        }
  return os;
}
//----------------------------------------------------------------------
  template<class E>
dynamicexp<E>& dynamicexp<E>::setExponent(size_type i, value_type d)
{
  assert(i<_size);
  (*this)[i]=d;

  //  while(_tab[_size-1]==0 && _size>0) _size--;

  //    if (i < 0);
  //    else if (i+1 < _size)
  //            _tab[i] = d;
  //    else if (i >= _size && d) {
  //            E* aux = dynamicexp<E>::alloc(i+1);
  //            memset(aux,0,sizeof(E)*(i+1));
  //            memcpy(aux,_tab,sizeof(E)*_size);
  //            //memset(aux+size,0,i-size);
  //            aux[i] = d;
  //            delete [] _tab;
  //            _tab = aux;
  //            //realloc(_tab,sizeof(E)*(i+1));
  //            //memset(_tab+size,0,i-size);
  //            //_tab[i] = d;
  //            _size = i+1;
  //    }
  //    else if (i >= _size && !d);
  //    else if (d)
  //            _tab[i] = d;
  //    else {
  //            int j = i - 1;
  //            while (j >= 0 && !_tab[j]) --j;
  //            _size = j+1;
  //            if (j < 0) {
  //                    clear();
  //                    _tab = NULL;
  //            }
  //            else {
  //                    E * aux = dynamicexp<E>::alloc(j+1);
  //                    memcpy(aux,_tab,sizeof(E)*(j+1));
  //                    clear();
  //                    _tab = aux;
  //            }
  //    }
  return *this;
}
//----------------------------------------------------------------------
template<class E>
int lvar (const dynamicexp<E> & A) {
  int r=A._size-1;
  while(r>=0 && (A[r]==0)) r--;
  return r;
}
//----------------------------------------------------------------------
template<class E>
void erase (dynamicexp<E> & A) {
  A.clear();
  A._tab = NULL;
  A._size = 0;
}
//----------------------------------------------------------------------//
template <class E>
  inline VAL<OP<'+',dynamicexp<E>,dynamicexp<E> > >
operator+(const dynamicexp<E> & a, const dynamicexp<E> & b)
{
  return VAL<OP<'+',dynamicexp<E>,dynamicexp<E> > >
        (OP<'+',dynamicexp<E>,dynamicexp<E> >(a,b));
}
//----------------------------------------------------------------------//
template <class E> inline
void assign(dynamicexp<E> & a,
        const OP<'+',dynamicexp<E>,dynamicexp<E> > & M)
{
  add(a,M.op1,M.op2);
}
//----------------------------------------------------------------------//
template<class E>
void add (dynamicexp<E> & r,
        const dynamicexp<E> & A, const dynamicexp<E> & B);
//----------------------------------------------------------------------//
template<class E>
void add (dynamicexp<E> & r, 
          const dynamicexp<E> & A, 
          const dynamicexp<E> & B)
{
  r.init(std::max(A.size(),B.size()) );
  VECTOR::add(r,A,B);
}
//----------------------------------------------------------------------//
__END_NAMESPACE_SYNAPS
//----------------------------------------------------------------------//
#endif // synaps_mpol_dynamicexp_h_