synaps/mpol/tinyexp.h

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

#include <iostream>
#include <cstdlib>
#include <string>
#include <synaps/init.h>


__BEGIN_NAMESPACE_SYNAPS

template<char X, int N, class E=char> 
struct tinyexp {

  typedef E   exponent_t;
  typedef int degree_t;
  typedef tinyexp<X,N,E> self_t;
  
  // constructors
  tinyexp() {tab = (E *)malloc(sizeof(E)*N);}
  tinyexp(const tinyexp<X,N,E> & d)
  {
    tab = (E *)malloc(sizeof(E)*N);
    memcpy(tab,d.tab,sizeof(E)*N);
  }
  tinyexp(int s, E *t){
    tab = (E *)malloc(sizeof(E)*N);
    for(int i=0;i<s;i++) tab[i]=t[i];
  }

  // destructor
  ~tinyexp(){if (tab) delete [] tab;}

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

  // affectation operator
  tinyexp & operator = (const tinyexp & A) 
  {
    memcpy(tab,A.tab,sizeof(E)*N);
    return *this;
  }
  self_t & operator+= (const tinyexp<X,N,E>  & B) 
  {
    for (int i = 0; i < N; ++i)  tab[i] += B.tab[i];
    return *this;
  }

  void reserve(int d) {}

  self_t setExponent(int i, int d) 
    {
      tab[i]=d; return *this;
    }
  
  friend bool operator == (const tinyexp & A, const tinyexp & B) 
  {
    return memcmp(A.tab,B.tab,sizeof(E)*N) == 0;
  }

  // Data
  E *tab;
};

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

template<char X,int N,class E>
ostream & operator << (ostream & os, const tinyexp<X,N,E> & t) {
  for (int i = 0; i < N; ++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 SDegree (tinyexp<X,N,E> & A, int i, int d) 
{
  if (i < 0 && i>= N); else A.tab[i] = d;
}

template<char X,int N, class E>
int lvar (const tinyexp<X,N,E> & A) {
  int i=N-1;
  while(i>=0 && A[i]==0) i--;
  return i;
}

template<char X,int N,class E>
void erase (tinyexp<X,N,E> & A) {
        free(A.tab);
        A.tab = NULL;
}



template<char X,int N,class E>
void add (tinyexp<X,N,E>& r, const tinyexp<X,N,E>& A, const tinyexp<X,N,E>& B)
{
  for (int i=0; i < N; ++i) r.tab[i] = A.tab[i]+B.tab[i];
}


__END_NAMESPACE_SYNAPS

#endif // SYNAPS_MPOL_TINYEXP_H