/*************************************************************/
/*                                                           */
/*  Copyright (c) 1990                                       */
/*  Darrell L. Whitley                                       */
/*  Computer Science Department                              */
/*  Colorado State University                                */
/*                                                           */
/*  Permission is hereby granted to copy all or any part of  */
/*  this program for free distribution.   The author's name  */
/*  and this copyright notice must be included in any copy.  */
/*                                                           */
/*************************************************************/
/***************************************************************************
                               main_bin.c

 This sample main() driver function implementation can be used with the
 classic binary genetic algorithm (i.e. where strings of 1's and 0's 
 are manipulated.)

 ***************************************************************************

 This file provides an example of a genetic algorithm implementation using
 the ga_ modules's subroutines provided with the Genitor package.  For most
 experiments, you should be able to USE THE MODULES WITHOUT ALTERATIONS.
 However, your MAIN() AND EVAL() PROCEDURES CAN DIFFER considerably depending
 on your application.  Further, once you are familiar with the coding
 conventions of the Genitor package, you may wish to
 CREATE YOUR OWN GENETIC OPERATORS to add to the library of operators
 distributed with Genitor.  The hope is that you will find the basic Genitor
 modules useful in whatever form of experiment you undertake.

 While, this main() procedure is provided only as an example, it does display
 conventions to which you must adhere in order to use the modular Genitor
 environment.  To find out more about coding with the Genitor package, you
 must read the documentation included with the package before beginning.

 ***************************************************************************/
            
#include <stdio.h>
#include <ctype.h>
#include "ga_random.h"
#include "gene.h"
#include "ga_params.h"
#include "ga_global.h"
#include "ga_pool.h"
#include "ga_selection.h"
#include "ga_status.h"
#include "ga_signals.h"
#include "op_adapt_mutate.h"
#include "op_red_surrog.h"


/*******************************************
 Declare evaluation function which tells you
 how "good" a particular gene's solution is.
 NOTE: the input parameters for the eval
       function should always be a gene and
       the gene's length
 *******************************************/

#include "eval_bin.h"



int
main (argc, argv)
int   argc;
char *argv[];
{
 int     i;
 GENEPTR mom, dad, child;
 int     numdiffs;

/**********************
 Setup signal handlers. 
 **********************/
 setup_signal();


/*************************************************************
 Set the global parameters according to command line arguments.
 *************************************************************/
 argc--;
 argv++;
 parse_command_line (argc, argv);
 
/**************************
 Print Algorithm Parameters
 **************************/
 fprintf (stdout, "\n");
 print_params(stdout);
 fprintf (stdout, "\n");

/********************************
 Seed the Random Number Generator
 ********************************/
 srandom(RandomSeed);


/******************************************************
 Allocate a genetic pool referenced by the global, Pool
 ******************************************************/
 if ( !(Pool = get_pool(PoolSize, StringLength)) )
    fatal_error(NULL);


/**************************************
 Initialize the genetic pool with data.
 **************************************/
 init_pool (SeedPool, Pool, 0, Pool->size, bin_eval); 


/***********************************
 Sort the initial genetic pool data.
 ***********************************/
 sort_pool (Pool);


/*******************************************************
 Allocate temporary storage for parents of reproduction.
 *******************************************************/
 mom = get_gene (Pool->string_length);
 dad = get_gene (Pool->string_length);


 /**********
  Optimize !
  **********/
 for (/* CurrentGeneration already set :
         either intialized to 0 in its declartion OR
         initialized by a restart of a previous experiment */;

         CurrentGeneration < NumberTrials; 
         CurrentGeneration++)
    {

    /********************************** 
     Choose two genes for reproduction.
     **********************************/
     get_parents(mom, dad, Pool, linear, SelectionBias);


    /************************************************************
     Reproduce using the 'reduced surrogate crossover' operator.
     A difference factor (actually, the hamming distance) between
     the two parents is returned.
     ************************************************************/
     numdiffs =red_surrogate_cross(mom->string,dad->string,Pool->string_length);

    /*******************************************************
     Mutate the child according to the difference between 
     its parents (if mutation is turned on)
     *******************************************************/

     if (MutateRate > 0.0)
      adaptive_mutate (mom->string, Pool->string_length, numdiffs, MutateRate);

    /****************************************************************
     Choose one of the two offspring to insert into the genetic pool.
     ****************************************************************/
     child = ((bitgen() == 0) ? mom : dad);

    /**************************
     So, kid, how good are you?
     **************************/
     child->worth = bin_eval (child->string, StringLength);

    /******************************************************
     Insert new gene into population according to its worth
     ******************************************************/
     insert_gene (child, Pool);

    /*******************************************************************
     If the StatusInterval parameter was set and this is the appropriate
     time, print the population best, worst, mean, and average to stdout
     *******************************************************************/
     if (StatusInterval && !(CurrentGeneration % StatusInterval))
        show_progress (stdout, Pool, CurrentGeneration);

    /*****************************************************************
     If the DumpInterval parameter was set and this is the appropriate
     time, save the population and key parameters to disk for later
     reference (or to restart execution later.
     *****************************************************************/
     if (DumpInterval && !(CurrentGeneration % DumpInterval))
        dump_status(Pool, DumpBase);
    }
 

 /*****************
  Summarize Results
  *****************/
  final_pool (FinalPool, Pool, CurrentGeneration); 
  fprintf (stdout, "\n");
  print_pool (stdout, Pool, 0, 1);
}