augmentedalgebras.H

#ifndef _AUGMENTEDALGEBRAS_H_
#define _AUGMENTEDALGEBRAS_H_

#include "affinealgebras.H"
using namespace std;


template <class K>
class AugmentedAlgebra : public AffineAlgebra<K> {
public:

  map<long, K> epsilon;

  Polynomial<K> new_variable(const string& name, const K& aug){
    Polynomial<K> ans;    

    ans= AffineAlgebra<K>::new_variable(name);
    epsilon[this->var_in_use]= aug;

    return ans;
  }
 
  virtual void swap_variables_order(long i, long j,list< Polynomial<K> >& polys){
    K dummy;

    AffineAlgebra<K>::swap_variables_order(i,j,polys);
    dummy= epsilon[i];
    epsilon[i]= epsilon[j];
    epsilon[j]= dummy;
  }

  // code below is the same as for affinealgebra !!
  // however, since we redefine a method with the
  // same name (but different arguments), the
  // compiler would be confused if we did not rewrite
  // this one as well.
  virtual void swap_variables_order(long i, long j){
    list< Polynomial<K> > empty_list;
    
    this->swap_variables_order(i,j,empty_list);
  }




  virtual void kill_top_variable(const Polynomial<K>& replacement,list< Polynomial<K> >& polys){
    AffineAlgebra<K>::kill_top_variable(replacement,polys);
    epsilon.erase(this->var_in_use + 1);
  }


  virtual void kill_top_variable(const Polynomial<K>& replacement){
    list< Polynomial<K> > empty_list;

    this->kill_top_variable(replacement,empty_list);
  }



  friend ostream& operator<<(ostream& os, const AugmentedAlgebra<K>& R){
    typename map<long, string>::const_iterator it_gen;
    typename map<long, K>::const_iterator it_aug;
    typename list< Polynomial<K> >::const_iterator it_rel;

    os << "generators:" << endl;
    for(it_gen= R.names.begin(), it_aug= R.epsilon.begin(); 
        it_gen!= R.names.end(); 
        it_gen++, it_aug++)
      os << it_gen->second << " whose augmentation is "
         << it_aug->second << endl;
    
    os << endl << "relations:" << endl;
    for(it_rel=R.relations.generators.begin(); 
        it_rel!= R.relations.generators.end(); it_rel++)
      os << *it_rel << endl;

    return os;
  }
  
  friend ofstream& operator<<(ofstream& file, AugmentedAlgebra<K>& A){
    
    // write the underlying affine algebra
    AffineAlgebra<K> *ptr;
    ptr= &A;
    file << *ptr;
    // write the augmentations
    for(long i=1; i <= A.var_in_use; i++)
      file << A.epsilon[i] << " ";
    
    return file;
  }
  
  friend void operator>>(ifstream& file, AugmentedAlgebra<K>& A){
    
    //read the underlying affine algebra
    AffineAlgebra<K> *ptr;
    ptr= &A;
    file >> *ptr;
    //read the degrees
    long deg;
    for(long i=1; i<= A.var_in_use; i++){
      file >> deg;
      A.epsilon[i]=deg;
    }
  }
  
  


};





#endif

---