abshom.H

#ifndef _ABSHOM_H_
#define _ABSHOM_H_

#include <iostream>
#include <map>
#include <algebras.H>
using namespace std;



template <class K>
class AbstractHomomorphism {
protected:
  map <long, Polynomial<K> > images;

  long highest_var;
public:
  AbstractHomomorphism(){

    highest_var= 0;
  }
  void clear(){

    images.clear();
    highest_var= 0;
  }
  //getter for images
  Polynomial<K> of_generator(long var) const
  {
    return images.find(var)->second;
  }
  

  void set_image(long var, const Polynomial<K>& P){
    long n;

    images[var]= P;
    n= P.nvars();
    if( n > highest_var)
      highest_var= n;
  }
  bool has_image_set(long var) const {

    return (images.count(var) > 0);
  }
  void make_identity(long n){

    images.clear();

    for(long i=1; i<=n; i++)
      images[i]= Polynomial<K>( PowProd(i) );

    highest_var= n;
  }
  void swap(long i, long j){
    Polynomial<K> dummy;

    dummy= images[i];
    images[i]= images[j];
    images[j]= dummy;
  }


  Polynomial<K> of(const Polynomial<K>& P) const {
    Polynomial<K> ans, temp;
    long d;

    ans= P;
    if(images.empty()){   //in this case this is the zero hom
      ans.sets_to_zero(); //NOT RECOMMENDED though!
      return ans;         //note that the alphabet is wrong !
    }
    //else
    ans.alphabet= images.begin()->second.alphabet;

    ans.shift_variables(highest_var);
    d= P.nvars();
    for(long i= 1; i <= d; i++)
      if(P.involves_variable(i)){
        if(images.count(i) > 0)
          temp= images.find(i)->second;
        else
          temp.sets_to_zero();

        ans.substitute_variable(i + highest_var, temp);
      }
    return ans;
  }

  AbstractHomomorphism<K>& operator*=(const AbstractHomomorphism<K>& f){
    typename map< long, Polynomial<K> >::const_iterator it;
    AbstractHomomorphism ans;

    for(it= f.images.begin(); it!= f.images.end(); it++)
      ans.set_image( it->first, this->of( it->second ) );

    *this= ans;

    return *this;
  }
  AbstractHomomorphism<K> operator*(const AbstractHomomorphism<K>& f) const {
    typename map< long, Polynomial<K> >::const_iterator it;
    AbstractHomomorphism ans;

    for(it= f.images.begin(); it!= f.images.end(); it++)
      ans.set_image( it->first, this->of( it->second ) );

    return ans;
  }
  friend ostream& operator<<(ostream& os, const AbstractHomomorphism<K>& f){
    typename map< long, Polynomial<K> >::const_iterator it;

    for(it= f.images.begin(); it!= f.images.end(); it++)
      os << "variable " << it->first <<" --> " << it->second << endl;

    return os;
  }


  friend ofstream& operator<<(ofstream& file, AbstractHomomorphism<K>& f){
    typename map< long, Polynomial<K> >::iterator it;
        
    for(it= f.images.begin(); it!= f.images.end(); it++){
      file << it->first << " ";
      file << it->second;
      file << " ";
    }
    
    file << 0 << " ";
    return file;
  }
  
  friend void operator>>(ifstream& file, AbstractHomomorphism<K>& f){
    long index;
    Polynomial<K> P;
    
    f.clear();
        
    file >> index;

    while(index != 0){
      file >> P;
      f.set_image(index, P);
      file >> index;
    }
      
  }




};







#endif

---