dynamicexp.hpp

Go to the documentation of this file.

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

#include <stdlib.h>
#include <iostream>
#include <string>
#include <iterator>
#include <cassert>
//#include <synaps/arithm/REF.hpp>
//#include <synaps/base/COUNT.hpp>

#include <realroot/array.hpp>

//======================================================================
namespace mmx {
//======================================================================
template<class E=int>
struct dynamic_exp {

  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 dynamic_exp<E> self_t;

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

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

  dynamic_exp(int s, E *t): _size(s){
    assert(s <= sizeof(t)/sizeof(E));
    _tab = dynamic_exp<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
  ~dynamic_exp(){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 = dynamic_exp<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 = dynamic_exp<E>::alloc(s);
      //for(size_type i=0;i<s;i++) _tab[i]=(exponent_t)0;
    }
    else {
      delete [] _tab;
      _tab = dynamic_exp<E>::alloc(s);
      _size=s;
    }
  }
  void resize(size_type s)
  {
    if(s<=_size)
      _size = s;
    else{
      E* _tmp =_tab;
      _tab = dynamic_exp<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 = dynamic_exp<E>::alloc(s);
  }

  self_t& set_expt(size_type i, value_type d);

  friend bool operator == (const dynamic_exp & A, const dynamic_exp & 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 dynamic_exp & A, const dynamic_exp & 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 dynamic_exp<E>::degree_t degree(const dynamic_exp<E> & t)
{
  typename dynamic_exp<E>::degree_t d(0);
  for (typename dynamic_exp<E>::size_type i = 0; i < t._size; ++i) d+=t[i];
  return(d);
}
//----------------------------------------------------------------------
template<class E>
std::ostream & operator << (std::ostream & os, const dynamic_exp<E> & t) {
  bool first=true;
  if(t._size)
    for (typename dynamic_exp<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>
dynamic_exp<E>& dynamic_exp<E>::set_expt(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 = dynamic_exp<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 = dynamic_exp<E>::alloc(j+1);
  //            memcpy(aux,_tab,sizeof(E)*(j+1));
  //            clear();
  //            _tab = aux;
  //        }
  //    }
  return *this;
}
//----------------------------------------------------------------------
template<class E>
int lvar (const dynamic_exp<E> & A) {
  int r=A._size-1;
  while(r>=0 && (A[r]==0)) r--;
  return r;
}
//----------------------------------------------------------------------
template<class E>
void erase (dynamic_exp<E> & A) {
  A.clear();
  A._tab = NULL;
  A._size = 0;
}
//----------------------------------------------------------------------//
// template <class E>
//   inline VAL<OP<'+',dynamic_exp<E>,dynamic_exp<E> > >
// operator+(const dynamic_exp<E> & a, const dynamic_exp<E> & b)
// {
//   return VAL<OP<'+',dynamic_exp<E>,dynamic_exp<E> > >
//  (OP<'+',dynamic_exp<E>,dynamic_exp<E> >(a,b));
// }
//----------------------------------------------------------------------//
// template <class E> inline
// void assign(dynamic_exp<E> & a,
//  const OP<'+',dynamic_exp<E>,dynamic_exp<E> > & M)
// {
//   add(a,M.op1,M.op2);
// }
//----------------------------------------------------------------------//
template<class E>
void add (dynamic_exp<E> & r,
    const dynamic_exp<E> & A, const dynamic_exp<E> & B);
//----------------------------------------------------------------------//
template<class E>
void add (dynamic_exp<E> & r, 
      const dynamic_exp<E> & A, 
      const dynamic_exp<E> & B)
{
  r.init(std::max(A.size(),B.size()) );
  array::add(r,A,B);
}
//======================================================================
} //  namespace mmx 
//======================================================================
#endif // realroot_dynamic_exp_hpp