FPGroup.h

Go to the documentation of this file.

// Copyright (C) 2005 Alexander Ushakov
// Contents: Definition of class FPGroup
//
// Principal Authors: Alexander Ushakov
//
// Revision History:
//

#ifndef _FPGROUP_H_
#define _FPGROUP_H_


#include <iostream>
#include <vector>
#include <string>
#include <strstream>


#include "Word.h"
#include "Alphabet.h"

using namespace std;


//---------------------------------------------------------------------------//
//--------------------------------- FPGroup ---------------------------------//
//---------------------------------------------------------------------------//



class FPGroup
{
  
  //                                                     //
  //  Constructors                                       //
  //                                                     //

 public:
  
  FPGroup( int num=0 );
  //  FPGroup( const vector< string >& genNames );
  //  FPGroup( const vector< string >& genNames , const vector< Word >& relators );
  FPGroup( int numOfGen , const vector< Word >& relators );
  FPGroup( const FiniteAlphabet& a );
  FPGroup( const FiniteAlphabet& a, const vector< Word >& relators );  
  
  //                                                     //
  //  Accessors:                                         //
  //                                                     //

 public:

  inline int numberOfGenerators( ) const { return numOfGenerators; }
  inline const vector< string >& getGeneratorsNames( ) const { return theAlphabet.getLetters(); }
  inline const FiniteAlphabet& getAlphabet( ) const { return theAlphabet; }  
  // Get the relators
  inline const vector< Word >& relators( ) const { return theRelators; }

  

  Word randomEqWord_Baltimore( const Word& w , int length , float conj_param ) const;

  
  

  Word randomIdentity_Stack( int length ) const;


  Word randomIdentity_Classic( int length , float conj_param ) const;
  
  Word randomIdentity_Baltimore( int length , float conj_param ) const;


  FPGroup triangulatePresentation( ) const;

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

 public:
  

  //                                                     //
  //  SWIG functions:                                    //
  //                                                     //

   /*
#ifdef SWIG
%extend {

  char* __str__( ) const {
    strstream ostr;
    ostr << *self << ends;
    return ostr.str( );
  }

  Word read( const char* str ) {
    Word result;
    self->readWord( str , result );
    return result;
  }

  char* write( const Word& word ) const {
    strstream ostr;
    self->writeWord( ostr , word ) << ends;
    return ostr.str( );
  }

  char* write( const Mapping& m ) const {
    strstream ostr;
    self->writeMapping( ostr , m ) << ends;
    return ostr.str( );
  }

}
#endif
   */

  //                                                     //
  //  Internal functions                                 //
  //                                                     //
  
 public:
  
  static vector< string > initializeGenNames( int num );
  
 private:
  
  friend ostream& operator << ( ostream& os , const FPGroup& group );
  friend istream& operator >> ( istream& is , FPGroup& group );
  
  
  //                                                     //
  //  Data members                                       //
  //                                                     //
  
 protected:
  
  int numOfGenerators;
  // does it make sense to have this variable? You can change it by generatorsNames.size( )
  //  vector< string > generatorsNames;
  vector< Word > theRelators;
  
  FiniteAlphabet theAlphabet;
  bool useDefaultAlphabet;  
};


#endif