/*************************************************************/
/*                                                           */
/*            Implementation for variable automata           */
/*                                                           */
/*************************************************************/
/*

                Finite state machines
                Variable size
                Dan Ashlock 12/20/00

                Modified to work with DNA 6/20/01

*/
#include <iostream.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>

#include "vaut.h"

aut::aut(){//creates a completely empty automata

   n=0;
   states=(state *)0;

}

aut::aut(int nv){//calls the create method to 
                 //allocate a random n-state automata

  n=0;
  states=(state *)0;
  create(nv);

}

aut::aut(const aut &b){//copy constructor

int i,j;

  n=b.n;
  states=new state[n];
  n=b.n;
  inita=b.inita;
  inits=b.inits;
  for(i=0;i<n;i++)for(j=0;j<Vstates;j++){
     states[i].resp[j]=b.states[i].resp[j];
     states[i].tran[j]=b.states[i].tran[j];
  }
}

aut::~aut(){//deletes the states - which are presently the onlt dynamically
            //allocated feature of the system

   delete [] states;

}

void aut::create(int nv){//allocate the requested number of states and
                         //call the recreate method to fill in 
                         //random transitions and responses
int i;

   //cout << "create" << endl;
   if(states)delete [] states;  //idiot check...

   n=nv;
   states=new state[nv];
   recreate();

}

void aut::recreate(){//fill in the random transition and response 
                     //values in an automata of known size.

int i,j;

   inits=lrand48()%n;
   inita=lrand48()%VAsize;
   for(i=0;i<n;i++){
     for(j=0;j<Vstates;j++){
       states[i].resp[j]=lrand48()%VAsize;
       states[i].tran[j]=lrand48()%n;
     }
   }
}

const aut &aut::operator=(const aut &right){//overload "="

int i,j;

  if(&right != this){//for self assignment just don't do a thing
    if(n!=right.n){//fix the size, if it needs to be fixed
       delete [] states;
       n=right.n;
       states=new state[n];
    }  
    inita=right.inita;
    inits=right.inits;
    for(i=0;i<n;i++)for(j=0;j<Vstates;j++){
      states[i].resp[j]=right.states[i].resp[j];
      states[i].tran[j]=right.states[i].tran[j];
    }
  }

  return *this;

}

void aut::initTFT(){//create a TFT, state streched to fill the automata

int i,j;

  if(n==0)create(1);
  inits=0;
  inita=0;
  for(i=0;i<n;i++){
    for(j=0;j<Vstates;j++){
      states[i].resp[j]=j%VAsize;
      states[i].tran[j]=(i+1)%n;
    }
  }
}

int aut::size(){//return the size of the auomata

   return(n);

}

int aut::reset(){//reset the automata, return initial action

   cur=inits;
   return(inita);

}

int aut::reset(int &wiis){//returns initial action and state

   wiis=inits;
   return(inita);

}

int aut::run(int inp){//run on input inp, update internal state and 
                      //return your response
int val;

   val=states[cur].resp[inp];
   cur=states[cur].tran[inp];
   return(val);   

}

int aut::run(int inp,int &stt){ //run on input inp with given state stt

int val;

   val=states[stt].resp[inp];
   stt=states[stt].tran[inp];
   return(val);   

}
    
//genetic operations, other than two point crossover
    
void aut::mutateaction(){

  states[lrand48()%n].resp[lrand48()%Vstates]=lrand48()%VAsize;

}
    
void aut::mutatetransition(){

  states[lrand48()%n].tran[lrand48()%Vstates]=lrand48()%n;

}

void aut::copystatemutation(){

  states[lrand48()%n]=states[lrand48()%n];

}

void aut::initialmutation(){

  if(lrand48()%2)inits=lrand48()%n; else inita=lrand48()%VAsize;

}

//automata printing routine
void aut::printn(ostream &aus){//numerical printing routine

int i,j;
char cv[18]="0123456789";

  aus << "--------------" << endl;
  aus << "States:" << n << "." << endl;
  aus << "Start:" << cv[inita] << "->" << inits << endl;
  aus << "   ";
  for(i=0;i<Vstates;i++){
    aus << "If " << cv[i] << " ";
    if(i<Vstates-1)aus << "|"; else aus << endl;
  }
  for(i=0;i<3+6*Vstates;i++)aus << "-";
  aus << endl;
  for(i=0;i<n;i++){ 
    aus.width(2);aus << i;
    aus << ")";
    for(j=0;j<Vstates;j++){
      aus << cv[states[i].resp[j]] << "->";
      aus.width(2);aus << states[i].tran[j];
      if(j<Vstates-1)aus << "|"; else aus << endl;
    }
  }
  for(i=0;i<3+6*Vstates;i++)aus << "-";
  aus << endl;

}

//fitness funtions from chapter 6 on OMAL
//assorted fitness functions

int aut::predict(int *ref,int bits){

int s,a,c,i,z;

  s=inits;
  a=inita;
  c=0;
  for(i=0;i<bits;i++){
    //cout << a << " " << ref[i] << endl;
    if(a==ref[i])c++;
    z=states[s].tran[ref[i]];
    a=states[s].resp[ref[i]];
    s=z;
  }
  return(c);
}

int aut::selfdri(){

int *used;
int s,a,c,z,i;

   used=new int[VAsize*n];  //create a state tracking zone

   for(i=0;i<VAsize*n;i++)used[i]=0;
   s=inits;
   a=inita;
   c=0;
   i=VAsize*s+a;
   while(!used[i]){ 
     //cout << s << " " << a << endl;
      c++;   
      used[i]=1;
      z=states[s].tran[a];
      a=states[s].resp[a];
      s=z;
      i=VAsize*s+a;
   }
   
   delete [] used;     //get rid of the state tracking zone

   return(c);

}

//automata printing routine
ostream &operator<<(ostream & aus,aut & m){

int i,j;
char cv[18]="CGATBDEFHIJKLMNOP";

  if(m.n==0){
    aus << "EMPTY AUTOMATA" << endl;
    return(aus);
  }

  aus << "--------------" << endl;
  aus << "States:" << m.n << "." << endl;
  aus << "Start:" << cv[m.inita] << "->" << m.inits << endl;
  aus << "   ";
  for(i=0;i<Vstates;i++){
    aus << "If " << cv[i] << " ";
    if(i<Vstates-1)aus << "|"; else aus << endl;
  }
  for(i=0;i<3+6*Vstates;i++)aus << "-";
  aus << endl;
  for(i=0;i<m.n;i++){ 
    aus.width(2);aus << i;
    aus << ")";
    for(j=0;j<Vstates;j++){
      aus << cv[m.states[i].resp[j]] << "->";
      aus.width(2);aus << m.states[i].tran[j];
      if(j<Vstates-1)aus << "|"; else aus << endl;
    }
  }
  for(i=0;i<3+6*Vstates;i++)aus << "-";
  aus << endl;
  return(aus);
}

int charid(char c){

int j;
char cv[18]="CGATBDEFHIJKLMNOP";

   j=0;
   while((j<17)&&(cv[j]!=c))j++;
   if(j==17)j=0;
   return(j);

}

//automata reading routine, only good for binary automata so far,
//in the PD metaphore
istream &operator>>(istream & aus,aut & m){

int i,j,k,nv;
char inp[256];

   aus.getline(inp,255);
   aus.getline(inp,255);
   i=0;
   while((!isdigit(inp[i]))&&(i<strlen(inp)))i++;
   if(i>=strlen(inp))return(aus); //hopeless, give up
   nv=atoi(inp+i);
   //cout << nv << endl;
   m.create(nv);
   aus.getline(inp,255);
   i=0;
   while((inp[i]!=':')&&(i<strlen(inp)))i++;
   if(inp[i]!=':')return(aus); //give up
   i++;

   m.inita=charid(inp[i]);

   i+=3;
   m.inits=atoi(inp+i);
   aus.getline(inp,255);
   aus.getline(inp,255);
   for(j=0;j<nv;j++){
     aus.getline(inp,255);
     i=0;
     while(inp[i]!=')')i++;
     i++;
     for(k=0;k<Vstates;k++){
       m.states[j].resp[k]=charid(inp[i]);     
       i+=3;
       m.states[j].tran[k]=atoi(inp+i);
       if(k<Vstates-1){
         while(inp[i]!='|')i++;
         i++;
       }
     }
   }
   aus.getline(inp,255);
   return(aus);
}

//two point crossover
void tpc(aut &a, aut &b){

int i,cp1,cp2,z,sw;
state sws;
    
   z=a.n;
   if(b.n<z)z=b.n;
   cp1=lrand48()%z;
   cp2=lrand48()%z;
   if(cp1>cp2){
      sw=cp1;
      cp1=cp2;
      cp2=sw;
   }
   for(i=cp1;i<cp2;i++){
      sws=a.states[i];
      a.states[i]=b.states[i];
      b.states[i]=sws;
   }
}

void copy(aut &a,aut &b){  //copy, with allocation if needed

int i,j;

   if(a.states){
     if(a.n!=b.n){
       delete [] a.states;
       a.states=new state[b.n];
       a.n=b.n;
     }
   } else {
       a.states=new state[b.n];
       a.n=b.n;
   }
   a.inita=b.inita;
   a.inits=b.inits;
   for(i=0;i<a.n;i++)for(j=0;j<Vstates;j++){
      a.states[i].resp[j]=b.states[i].resp[j];
      a.states[i].tran[j]=b.states[i].tran[j];
   }

}

void upcopy(aut &a,aut &b){//copy, with allocation if needed, and 
                           //duplicate a state
int i,j,dup;

   if(a.states)delete [] a.states;
   a.states=new state[b.n+1];
   a.n=b.n+1;
   a.inita=b.inita;
   a.inits=b.inits;
   for(i=0;i<b.n;i++)for(j=0;j<Vstates;j++){
      a.states[i].resp[j]=b.states[i].resp[j];
      a.states[i].tran[j]=b.states[i].tran[j];
   }

   //now flip a coin for every incoming arrow and reassign 
   //to the duplicated state on `heads'
   dup=lrand48()%b.n;
   a.states[b.n]=a.states[dup];
   for(i=0;i<b.n;i++)
     for(j=0;j<Vstates;j++)
       if(a.states[i].tran[j]==dup){
         if(lrand48()%2)a.states[i].tran[j]=b.n;
       }

}