//-----------------------------------------ga_tutorial.cpp--------------------------------------
//
//   code to illustrate the use of a genetic algorithm to solve the problem described
//  at www.ai-junkie.com
//
//   by Mat Buckland aka fup
//
//-----------------------------------------------------------------------------------------------
#include <string>
#include <stdlib.h>
#include <iostream.h>
#include <time.h>
#include <math.h>

using std::string;

#define CROSSOVER_RATE            0.7
#define MUTATION_RATE             0.001
#define POP_SIZE                  100         //must be an even number
#define CHROMO_LENGTH             300
#define GENE_LENGTH               4
#define MAX_ALLOWABLE_GENERATIONS   400

//returns a float between 0 & 1
#define RANDOM_NUM      ((float)rand()/(RAND_MAX+1))

//----------------------------------------------------------------------------------------
//
//   define a data structure which will define a chromosome
//
//----------------------------------------------------------------------------------------
struct chromo_typ
{
   //the binary bit string is held in a std::string
  string   bits; 

   float     fitness;

   chromo_typ(): bits(""), fitness(0.0f){};
   chromo_typ(string bts, float ftns): bits(bts), fitness(ftns){}
};


/////////////////////////////////prototypes/////////////////////////////////////////////////////

void    PrintGeneSymbol(int val);
string  GetRandomBits(int length);
int     BinToDec(string bits);
float   AssignFitness(string bits, int target_value);
void    PrintChromo(string bits);
void    PrintGeneSymbol(int val);
int     ParseBits(string bits, int* buffer);
string  Roulette(int total_fitness, chromo_typ* Population);
void    Mutate(string &bits);
void    Crossover(string &offspring1, string &offspring2);



//-------------------------------main--------------------------------------------------
//
//-------------------------------------------------------------------------------------
int main()
{
   //seed the random number generator
   srand((int)time(NULL));

  //just loop endlessly until user gets bored :0)
  while (true)
  {
    //storage for our population of chromosomes.
    chromo_typ Population[POP_SIZE];

     //get a target number from the user. (no error checking)
     float Target;
     cout << "\nInput a target number: ";
     cin >> Target;
    cout << endl << endl;
    
     //first create a random population, all with zero fitness.
     for (int i=0; i<POP_SIZE; i++)
     {
        Population[i].bits     = GetRandomBits(CHROMO_LENGTH);
        Population[i].fitness = 0.0f;
     }

     int GenerationsRequiredToFindASolution = 0;

     //we will set this flag if a solution has been found
     bool bFound = false;

     //enter the main GA loop
     while(!bFound)
     {
        //this is used during roulette wheel sampling
        float TotalFitness = 0.0f;

        // test and update the fitness of every chromosome in the
      // population
        for (int i=0; i<POP_SIZE; i++)
        {
           Population[i].fitness = AssignFitness(Population[i].bits, Target);

           TotalFitness += Population[i].fitness;
        }

        // check to see if we have found any solutions (fitness will be 999)
        for (i=0; i<POP_SIZE; i++)
        {
           if (Population[i].fitness == 999.0f)
           {
          cout << "\nSolution found in " << GenerationsRequiredToFindASolution << " generations!" << endl << endl;;

              PrintChromo(Population[i].bits);

              bFound = true;

          break;
           }
        }

        // create a new population by selecting two parents at a time and creating offspring
      // by applying crossover and mutation. Do this until the desired number of offspring
      // have been created.
       
        //define some temporary storage for the new population we are about to create
        chromo_typ temp[POP_SIZE];

        int cPop = 0;
    
        //loop until we have created POP_SIZE new chromosomes
        while (cPop < POP_SIZE)
        {
           // we are going to create the new population by grabbing members of the old population
           // two at a time via roulette wheel selection.
           string offspring1 = Roulette(TotalFitness, Population);
           string offspring2 = Roulette(TotalFitness, Population);

        //add crossover dependent on the crossover rate
        Crossover(offspring1, offspring2);

           //now mutate dependent on the mutation rate
           Mutate(offspring1);
           Mutate(offspring2);

           //add these offspring to the new population. (assigning zero as their
        //fitness scores)
           temp[cPop++] = chromo_typ(offspring1, 0.0f);
           temp[cPop++] = chromo_typ(offspring2, 0.0f);

        }//end loop

        //copy temp population into main population array
        for (i=0; i<POP_SIZE; i++)
      {
           Population[i] = temp[i];
      }

        ++GenerationsRequiredToFindASolution;

        // exit app if no solution found within the maximum allowable number
        // of generations
        if (GenerationsRequiredToFindASolution > MAX_ALLOWABLE_GENERATIONS)
        {
           cout << "No solutions found this run!";

           bFound = true;
        }

     }

    cout << "\n\n\n";

  }//end while

   return 0;
}
      



//---------------------------------GetRandomBits-----------------------------------------
//
//   This function returns a string of random 1s and 0s of the desired length.
//
//-----------------------------------------------------------------------------------------
string   GetRandomBits(int length)
{
   string bits;

   for (int i=0; i<length; i++)
   {
      if (RANDOM_NUM > 0.5f)

         bits += "1";

      else

         bits += "0";
   }

   return bits;
}

//---------------------------------BinToDec-----------------------------------------
//
//   converts a binary string into a decimal integer
//
//-----------------------------------------------------------------------------------
int   BinToDec(string bits)
{
   int val          = 0;
   int value_to_add = 1;

   for (int i = bits.length(); i > 0; i--)
   {
      

      if (bits.at(i-1) == '1')

         val += value_to_add;

      value_to_add *= 2;
   
   }//next bit

   return val;
}


//---------------------------------ParseBits------------------------------------------
//
// Given a chromosome this function will step through the genes one at a time and insert
// the decimal values of each gene (which follow the operator -> number -> operator rule)
// into a buffer. Returns the number of elements in the buffer.
//------------------------------------------------------------------------------------
int ParseBits(string bits, int* buffer)
{
   
   //counter for buffer position
   int cBuff = 0;
   
   // step through bits a gene at a time until end and store decimal values
   // of valid operators and numbers. Don't forget we are looking for operator -
   // number - operator - number and so on... We ignore the unused genes 1111
   // and 1110
   
   //flag to determine if we are looking for an operator or a number
   bool bOperator = true;
   
   //storage for decimal value of currently tested gene
   int this_gene = 0;
   
   for (int i=0; i<CHROMO_LENGTH; i+=GENE_LENGTH)
   {
      //convert the current gene to decimal
      this_gene = BinToDec(bits.substr(i, GENE_LENGTH));
      
      //find a gene which represents an operator
      if (bOperator)
      {
         if ( (this_gene < 10) || (this_gene > 13) )
            
            continue;
         
         else
         {
            bOperator      = false;
            buffer[cBuff++] = this_gene;
            continue;
         }
      }
      
      //find a gene which represents a number
      else
      {
         if (this_gene > 9)
            
            continue;
         
         else
         {
            bOperator      = true;
            buffer[cBuff++] = this_gene;
            continue;
         }
      }
      
   }//next gene

   //   now we have to run through buffer to see if a possible divide by zero
   //   is included and delete it. (ie a '/' followed by a '0'). We take an easy
   //   way out here and just change the '/' to a '+'. This will not effect the
   //   evolution of the solution
   for (i=0; i<cBuff; i++)
   {
      if ( (buffer[i] == 13) && (buffer[i+1] == 0) )
      
         buffer[i] = 10;
   }

   return cBuff;
}
   
//---------------------------------AssignFitness--------------------------------------
//
//   given a string of bits and a target value this function will calculate its 
//  representation and return a fitness score accordingly
//------------------------------------------------------------------------------------
float AssignFitness(string bits, int target_value)
{

   //holds decimal values of gene sequence
   int buffer[(int)(CHROMO_LENGTH / GENE_LENGTH)];

   int num_elements = ParseBits(bits, buffer);
   
   // ok, we have a buffer filled with valid values of: operator - number - operator - number..
   // now we calculate what this represents.
   float result = 0.0f;

   for (int i=0; i < num_elements-1; i+=2)
   {
      switch (buffer[i])
      {
         case 10:

            result += buffer[i+1];
            break;

         case 11:
            
            result -= buffer[i+1];
            break;

         case 12:

            result *= buffer[i+1];
            break;

         case 13:
   
            result /= buffer[i+1];
            break;

      }//end switch

   }

   // Now we calculate the fitness. First check to see if a solution has been found
   // and assign an arbitarily high fitness score if this is so.

   if (result == (float)target_value)

      return 999.0f;

   else

      return 1/(float)fabs((double)(target_value - result));
   //   return result;
}

//---------------------------------PrintChromo---------------------------------------
//
// decodes and prints a chromo to screen
//-----------------------------------------------------------------------------------
void PrintChromo(string bits)
{   
   //holds decimal values of gene sequence
   int buffer[(int)(CHROMO_LENGTH / GENE_LENGTH)];
   
   //parse the bit string
   int num_elements = ParseBits(bits, buffer);
   
   for (int i=0; i<num_elements; i++)
  {
      PrintGeneSymbol(buffer[i]);
  }

   return;
}
   
//--------------------------------------PrintGeneSymbol-----------------------------
//   
//   given an integer this function outputs its symbol to the screen
//----------------------------------------------------------------------------------
void PrintGeneSymbol(int val)
{
   if (val < 10 )
      
      cout << val << " ";
   
   else
   {
      switch (val)
      {
         
      case 10:
         
         cout << "+";
         break;
         
      case 11:
         
         cout << "-";
         break;
         
      case 12:
         
         cout << "*";
         break;
         
      case 13:
         
         cout << "/";
         break;
         
      }//end switch
      
      cout << " ";
   }

   return;
}

//------------------------------------Mutate---------------------------------------
//
//   Mutates a chromosome's bits dependent on the MUTATION_RATE
//-------------------------------------------------------------------------------------
void Mutate(string &bits)
{
   for (int i=0; i<bits.length(); i++)
   {
      if (RANDOM_NUM < MUTATION_RATE)
      {
         if (bits.at(i) == '1')

            bits.at(i) = '0';

         else

            bits.at(i) = '1';
      }
   }

   return;
}

//---------------------------------- Crossover ---------------------------------------
//
//  Dependent on the CROSSOVER_RATE this function selects a random point along the
//  lenghth of the chromosomes and swaps all the  bits after that point.
//------------------------------------------------------------------------------------
void Crossover(string &offspring1, string &offspring2)
{
  //dependent on the crossover rate
  if (RANDOM_NUM < CROSSOVER_RATE)
  {
    //create a random crossover point
    int crossover = (int) (RANDOM_NUM * CHROMO_LENGTH);

    string t1 = offspring1.substr(0, crossover) + offspring2.substr(crossover, CHROMO_LENGTH);
    string t2 = offspring2.substr(0, crossover) + offspring1.substr(crossover, CHROMO_LENGTH);

    offspring1 = t1; offspring2 = t2;             
  }
}


//--------------------------------Roulette-------------------------------------------
//
//   selects a chromosome from the population via roulette wheel selection
//------------------------------------------------------------------------------------
string Roulette(int total_fitness, chromo_typ* Population)
{
   //generate a random number between 0 & total fitness count
   float Slice = (float)(RANDOM_NUM * total_fitness);
   
   //go through the chromosones adding up the fitness so far
   float FitnessSoFar = 0.0f;
   
   for (int i=0; i<POP_SIZE; i++)
   {
      FitnessSoFar += Population[i].fitness;
      
      //if the fitness so far > random number return the chromo at this point
      if (FitnessSoFar >= Slice)

         return Population[i].bits;
   }

   return "";
}