Map.h

Go to the documentation of this file.

#ifndef _MAP_H_
#define _MAP_H_

#include <iostream>

#include <vector>
#include "Word.h"
#include "errormsgs.h"

//                                                                //
// Map                                                            //
//                                                                //



class Map
{
  
public:
  
//   Map( ) : 
//     theDomain(0), 
//     theRange(0),
//     theDomainAlphabet(&(InfiniteAlphabet::defaultAlphabet)),
//     theRangeAlphabet(&(InfiniteAlphabet::defaultAlphabet)) {} 

  // copy constructor supplied by compiler
  

  

  Map( int domain_gens, int range_gens ) 
    : theDomain(domain_gens),
    theRange(range_gens),
    theDomainAlphabet(domain_gens),
    theRangeAlphabet(range_gens),
    theGeneratingImages(domain_gens)  { }

  

  Map(  int domain_gens, int range_gens, const vector<Word>& generatingImages ) 
    :theDomain(domain_gens),
    theRange(range_gens),
    theDomainAlphabet(domain_gens),
    theRangeAlphabet(range_gens),
    theGeneratingImages(generatingImages)  
  { 
    
    if (generatingImages.size() != domain_gens)
      msgs::error("wrong number of generating images in  Map::Map(domain,range,generatingImages)");
    
  }


  Map( const FiniteAlphabet&  domain_alph, const FiniteAlphabet& range_alph ) 
    : theDomain(domain_alph.size()),
      theRange(range_alph.size()),
      theDomainAlphabet(domain_alph),
      theRangeAlphabet(range_alph),
      theGeneratingImages(domain_alph.size())  { }

  

  Map(  const FiniteAlphabet&  domain_alph, const FiniteAlphabet& range_alph, 
        const vector<Word>& generatingImages ) 
    :theDomain(domain_alph.size()),
     theRange(range_alph.size()),
     theDomainAlphabet(domain_alph),
     theRangeAlphabet(range_alph),
     theGeneratingImages(generatingImages)  
  { 
    
    if (generatingImages.size() != theDomain)
      msgs::error("wrong number of generating images in  Map::Map(domain,range,generatingImages)");
    
  }
  // destructor supplied by compiler

  //                                                                //
  // Standard Operators                                             //
  //                                                                //


  bool operator == ( const Map& m ) const 
  {
    return ( theDomain == m.theDomain && theRange == m.theRange && theGeneratingImages == m.theGeneratingImages );
  }

  //                                                                //
  // Accessors / Modifiers                                          //
  //                                                                //

  int domainSize( ) const { return theDomain; }

  const FiniteAlphabet&  domainAlphabet( ) const { return theDomainAlphabet; }

  int rangeSize( ) const { return theRange; }

  const FiniteAlphabet&  rangeAlphabet( ) const { return theRangeAlphabet; }

 
  const vector<Word>& generatingImages( ) const { return theGeneratingImages; }

  Word generatingImages( int i ) const { 
    if (i < 0 || i >= theDomain)
      msgs::error("generating image index out of range in  Map::generatingImages(int)");
    return theGeneratingImages[i]; 
  } 

 
 void setGeneratingImages( const vector<Word> gi ) 
  {
    if (gi.size() != theDomain)
      msgs::error("wrong number of generating images in  Map::setGeneratingImages( const VectorOf<Word> )");
    theGeneratingImages = gi;
  }

  

 void setGeneratingImages( int i, const Word& e  ) 
  {

    if (i < 0 || i >= theDomain)
      msgs::error("generating image index out of range in  Map::setGeneratingImages(int, const Word&)");
    theGeneratingImages[i] = e;
  }


        
  //                                                                //
  // Mapping methods                                                //
  //                                                                //

  // computing images:
  // formally:


  Word imageOf( const Word& w ) const;



  friend Map composition( const Map& firstMap,
                          const Map& secondMap );
   


  Map operator | ( const Map& secondMap )
  { return composition(*this, secondMap); }
  


  //                                                                //
  // I/O                                                            //
  //                                                                //


  //------------------ Related global functions --------------------//
  
  friend ostream& operator << ( ostream& out, const Map& m ){
    m.printOn(out);
    return out;
  }

  friend istream& operator >> ( istream& in, Map& m ){
    m.readFrom(in);
    return in;
  }

  void printOn(ostream& ostr) const;
 
  void readFrom(istream& in);
private:
  char readChar(istream& in)const;


  // real data:
  int theDomain;
  int theRange;
  vector<Word> theGeneratingImages;

  FiniteAlphabet theDomainAlphabet;
  FiniteAlphabet theRangeAlphabet;
  
};


//                                                                //
// Random Maps                                                    //
//                                                                //
  
namespace RMap 
{

  Map getRandomWhiteheadAuto(  int n );


  Map getRandomAuto( int n, int l);
};

#endif