dynamicexp.hpp

Go to the documentation of this file.

/*********************************************************************
*      This file is part of the source code of BORDERBASIX software. *
*      (C) B. Mourrain,  INRIA                                       *
**********************************************************************
History: 
$Id: dynamicexp.hpp,v 1.1.1.1 2006/10/06 08:01:40 trebuche Exp $
**********************************************************************/
#ifndef _dynamicexp_H_
#define _dynamicexp_H_

#include <iostream>
#include <cstdlib>
#include <cstring>

template<char X,class E=char> 
struct dynamicexp {

  typedef E   exponent_t;
  typedef int degree_t;
  typedef dynamicexp<X,E> self_t;
  
  // constructors
  dynamicexp():size(0),tab(NULL){}
  dynamicexp(const dynamicexp<X,E> & d):size(d.size){
    if (size) {
      tab = (E *)malloc(sizeof(E)*size);
      memcpy(tab,d.tab,sizeof(E)*size);
    }
    else
      tab = NULL;
  }
  dynamicexp(int s, E *t): size(s){
    tab = (E *)malloc(sizeof(E)*size);
    for(int i=0;i<s;i++) tab[i]=t[i];
  }
  dynamicexp(int s):size(s){tab = (E *)malloc(sizeof(E)*size);}
  // destructor
  ~dynamicexp(){if (tab) free(tab);}

  E operator[] (int i) const {
    // if(i<0) cout <<"("<<*this<<"["<<i<<"])";
    return (i<size &&i>=0?tab[i]:0); }

  // affectation operator
  dynamicexp & operator = (const dynamicexp & A) {
    if (tab) free(tab);
    size = A.size;
    if (size) {
      tab = (E *)malloc(sizeof(E)*size);
      memcpy(tab,A.tab,sizeof(E)*size);
    }
    else
      tab = NULL;
    return *this;
  }
  self_t & operator+= (const self_t & B) ;

  void reserve(int s) 
    {
      if (!s) {
    size = 0;
    tab = NULL;
      }
      else {
    size = s;
    tab = (E *)malloc(sizeof(E)*size);
    memset(tab,0,sizeof(E)*s);
      }
    }

  self_t setExponent(int i, int d) 
    {
      SDegree (*this,i,d);
      return *this;
    }
  
  friend bool operator == (const dynamicexp & A, const dynamicexp & B) {
    if (A.size == B.size)
      return memcmp(A.tab,B.tab,sizeof(E)*A.size) == 0;
    return 0;
  }
  friend bool operator != (const dynamicexp & A, const dynamicexp & B) {
    return !(A==B);}
  // Data
  int size;
  E *tab;
};

template<char X,class E> inline 
typename dynamicexp<X,E>::degree_t Degree(const dynamicexp<X,E> & t) 
{
  typename dynamicexp<X,E>::degree_t d(0);
  for (int i = 0; i < t.size; ++i) d+=t[i];
  return(d);
}

template<char X,class E>
std::ostream & operator << (std::ostream & os, const dynamicexp<X,E> & t) {
  for (int i = 0; i < t.size; ++i)
    {
      if (t.tab[i] == 1)
    os <<"*"<<X<< i;
      else if (t.tab[i] == 0);
      else
    os <<"*"<<X << i << '^' <<(int)(t[i]);
    }
  return os;
}

// template<char X,class E>
// void build(dynamicexp<X,E> & A, int i, int d) {
//  if (!d) {
//      A.size = 0;
//      A.tab = NULL;
//  }
//  else {
//      A.size = i+1;
//      A.tab = (E *)malloc(sizeof(E)*A.size);
//      memset(A.tab,0,sizeof(E)*i);
//      A.tab[i] = d;
//  }
// }

template<char X,class E>
void build(dynamicexp<X,E> & A, int s, E *tab) {
    A.size = s;
    A.tab = (E *)malloc(sizeof(E)*s);
    memcpy(A.tab,tab,sizeof(E)*s);
}

// template<char X,class E>
// int GDegree (const dynamicexp<X,E> & A, int i) {
//  if (0 <= i && i < A.size)
//      return A.tab[i];
//  return 0;
// }

template<char X,class E>
void SDegree (dynamicexp<X,E> & A, int i, int d) {
    if (i < 0);
    else if (i < A.size-1)
        A.tab[i] = d;
    else if (i >= A.size && d) {
        E * aux = (E *)malloc(sizeof(E)*(i+1));
        memset(aux,0,sizeof(E)*(i+1));
        memcpy(aux,A.tab,sizeof(E)*A.size);
    //  memset(aux+A.size,0,i-A.size);
        aux[i] = d;
         free(A.tab);
        A.tab = aux;
        //realloc(A.tab,sizeof(E)*(i+1));
        //memset(A.tab+A.size,0,i-A.size);
        //A.tab[i] = d;
        A.size = i+1;
    }
    else if (i >= A.size && !d);
    else if (d)
        A.tab[i] = d;
    else {
        int j = i - 1;
        while (j >= 0 && !A.tab[j]) --j;
        A.size = j+1;
        if (j < 0) {
            free(A.tab);
            A.tab = NULL;
        }
        else {
            E * aux = (E *)malloc(sizeof(E)*(j+1));
            memcpy(aux,A.tab,sizeof(E)*(j+1));
            free(A.tab);
            A.tab = aux;
        }
    }
}

template<char X,class E>
int lvar (const dynamicexp<X,E> & A) {
    return A.size-1;
}

template<char X,class E>
void erase (dynamicexp<X,E> & A) {
    free(A.tab);
    A.tab = NULL;
    A.size = 0;
}


template<char X,class E>
dynamicexp<X,E> & dynamicexp<X,E>::operator+=(const dynamicexp<X,E>  & B) {
    if (size >= B.size)
      for (int i = 0; i < B.size; ++i)
        tab[i] += B.tab[i];
    else if (!size) {
        tab = (E *) malloc(sizeof(E)*B.size);
        memcpy(tab,B.tab,sizeof(E)*B.size);
        size = B.size;
    }
    else {
        E *aux;
        aux = (E *)malloc(sizeof(E)*B.size);
        memcpy(aux,B.tab,sizeof(E)*B.size);
        for (int i = 0; i < size; ++i)
            aux[i] += tab[i];
        free(tab);
        tab = aux;
        size = B.size;
    }
    return *this;
}
template<char X,class E>
void add (dynamicexp<X,E> & r, 
      const dynamicexp<X,E> & A, 
      const dynamicexp<X,E> & B)
{
  int N = std::max(A.size,B.size);
    r.size = N;
        r.tab = (E *) malloc(sizeof(E)*N);
    if (!A.size) 
      memcpy(r.tab,B.tab,sizeof(E)*B.size);
    else if(!B.size)
      memcpy(r.tab,A.tab,sizeof(E)*A.size);
        else if (A.size >= B.size){
      int i = 0;
      for (; i < B.size; ++i)
        r.tab[i] = A.tab[i]+B.tab[i];
      for(;i< A.size;i++)
        r.tab[i] = A.tab[i];
    }else{
      int i = 0;
      for (; i < A.size; ++i)
        r.tab[i] = A.tab[i]+B.tab[i];
      for(;i< B.size;i++)
        r.tab[i] = B.tab[i];
    }
}
#endif // //_dynamicexp_H_