pentstub.c

遗传规划工具

/*======================================================================+
| PGPC: Parallel Genetic Programming in C                               |
| (c) 1995 Genetic Algorithm Technology Corp. all rights reserved       |
|   written by David Andre                                              |
+======================================================================*/
/*======================================================================+
| FILE: pentstub.c                                                      |
| DESCRIPTION: Handles the i/o code and startup code for the            |
|              for the uniprocessor stub version.                       |
|                                                                       |
| REVISIONS:                                                            |
| Jan 24, 1995:  Works as of today, no known bugs.                      |
| Jan 25, 95, 1207am:  Added Random seed garnering capability           |
| Jan 26, 1995, 2:21pm:    Putatively done with seed garnering...       |
+======================================================================*/


#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>
#include <ctype.h>
#include <time.h>
#ifdef __BORLANDC__
#include <fcntl.h>
#include <io.h>
#include <sys\stat.h>
#else
#ifdef _ICC
#include <iocntrl.h>
#include <process.h>
#include <channel.h>
#include <semaphor.h>
#endif
#endif


#include "gp.h"
#include "gpshared.h"
#include "pentstub.h"
#include "proto.h"
#include "gpi_stub.h"

FitCaseInfo out_sample_fitness_cases[_dmax(1,NUM_OUT_SAMPLE_FIT_CASES)];


extern Population gpop;

int main()
{
    int perpetual_number;
    struct tm *now;
    time_t clck;
    char out_put_file_name[40];

    DoWelcomeMessage();
    printf("Sizes:\n");
    printf("sizeof Individual %d, sizeof comp_ind %d,\nPopGlobals %d, StartupInfo %d\n",
            sizeof(Individual), sizeof(CompInd),sizeof(PopGlobals), sizeof(StartupInfo));
    printf("sizeof eog %d, EurekaInfo %d\n",sizeof(EndGenInfo),
            sizeof(EurekaInfo));
    printf("sizeof Population %d\n**************\n", sizeof(Population));
    fflush(stdout);
    setbuf(stdout, (char *) NULL);   /*Is this needed?*/
    time(&clck);
    now = localtime (&clck);
    GetPerpetualNumber(&perpetual_number);
    ReadInputFile(_PRB_IN,&gpop);
    DoRandoms(&gpop,perpetual_number);
    WriteToArchive(&gpop,perpetual_number,asctime(now));
    MakeFunctionTable(&gpop);
    CreateRandomConstants(&gpop);
    ReadPrimedIndividuals(&gpop);
    WriteInfoToOutputFile(&gpop,out_put_file_name,perpetual_number,asctime(now));

	 MainGPLoop(&gpop,&gpop.pop_startup_info,clck);
    return(-1);
}

void MainGPLoop(Population * popptr, StartupInfo * paramptr,time_t start_time)/*;*/ /*MainGPLoop- funcdef - */
{
int gen;

    gen=0;
    gpi_PopCreation(popptr);
    #if (INIT_POP_CHECK)
       init_pop_check(popptr);
       exit(1);
    #endif					
    for (gen=0; !(gpentTerminationQuery(gen)); gen++) {
        gpi_EvaluateGeneration(gen,popptr);
        if (!gpentTerminationQuery(gen))
        {
            gpi_DoEndOfGenMessage(gen,popptr);
            gpi_ReproducePopulation(gen);
        }
    } /* End of main counter loop */	
    gpi_DoEurekaMessage(gen, popptr,start_time);
}

int gpentTerminationQuery(int gen)/*;*/ /*funcdef*/
{
#ifdef USE_USER_TERMINATION
#if (USE_USER_TERMINATION ==1)
		if (UserTermination(gen, gpop.best_fitness,&gpop))
			return(1);
		else
			return(0);
#endif
#endif	
if ((gen < ((int)((float) (gpop.pop_startup_info.num_generations)))) &&
				(gpop.best_fitness > RUN_END_CRITERION))
	 return(0);
else
	 return(1);
}

			
void PreparePrimedInd(Individual * ind,Population *pop)/*;*/ /*funcdef*/
{
    int i,j;

        ind->s_fitness = (float) UNDEFINED;
	ind->hits		 = 0;
	ind->beauty		 = 0;
	
	ind->current_number_of_adfs = NUM_INITIAL_ADFS;
	for (i=0;i<MAX_NUM_ADFS;i++)
		ind->adf_arity[i]=MIN_NUM_ADF_ARGS;
        for (j=0;j<NUM_RPBS;j++)
	{
		for (i=0;i<(*pop).num_general_functions;i++)
		 	ind->rpbs[j].function_vector[i] =  (*pop).function_assignment[j][i];	
	}
	for (j=0;j<MAX_NUM_ADFS;j++)
	{
		for (i=0;i<(*pop).num_general_functions;i++)
		 	ind->adfs[j].function_vector[i] =  (*pop).function_assignment[NUM_RPBS+j][i];	
	}
#if (DO_POOR_WHITE_TRASH_AUDIT)
        ind->num_ops_done=0;
#endif
}


void ReadPrimedIndividuals(Population *pop)/*;*/ /*funcdef*/
{
FILE *ifp;
FILE *fp;
int counter,front,back;
char ch;
    CreateIndividual(&(pop->pop_startup_info.primed_individual));
    PreparePrimedInd(&(pop->pop_startup_info.primed_individual),pop);
    if (((*pop).pop_startup_info.num_primed_individuals) > 0)
    	{
            counter=0;front=0;back=0;
            /*
   	    fp = fopen("foo","rt");
            while ((ch = getc(fp)) != EOF)
            {
                counter++;
                printf("%c",ch);
                if (ch == '(')
                    front++;
                if (ch == ')')
                    back++;
                if (front + back > 0 && front == back)
                    break;
             }

            printf("front %d, back %d,BUFSIZE %d,counter %d\n",front,back,BUFSIZ,counter);
            rewind(fp);
            fclose(fp);
            counter=0;front=0;back=0;
   	    fp = fopen("foo","rt");
            while ((ch = getc(fp)) != EOF)
            {
                counter++;
                printf("%c",ch);
                if (ch == '(')
                    front++;
                if (ch == ')')
                    back++;
                if (front + back > 0 && front == back)
                    break;
             }

            printf("front %d, back %d,BUFSIZE %d,counter %d\n",front,back,BUFSIZ,counter);
            rewind(fp);
            fclose(fp);
            */

            /*rewind(ifp);*/
            pop->primed_constants = TOTAL_NUMBER_OF_FUNCTIONS - 1;
            /*fflush(pop->out_file);*//**********************/
            fflush(stdout);
/*            ifp = fopen("foo","rt");            */
            ReadIndividual(ifp,&(pop->pop_startup_info.primed_individual));
/*            fclose(ifp); */
            PrintIndividual(&(pop->pop_startup_info.primed_individual),stdout);

  	}
}

void CreateRandomConstants(Population *pop)/*;*/ /*funcdef*/
{
int i;

    (*pop).num_constants =TOTAL_NUMBER_OF_FUNCTIONS-1;
    for (i=(*pop).num_constants;i<MAXNUMFORARANDOMCONSTANT;i++)
    {
        (*pop).pop_startup_info.random_constant_table[i] = RAND_CODE();
    }

    (*pop).num_constants = MAXNUMFORARANDOMCONSTANT+1;
}




void GetPerpetualNumber(int * pn)/*;*/ /*funcdef - startup - GetPerpetualNumber*/
{
FILE * xperp;
        xperp = fopen("perpet.out", "r");
        fscanf(xperp,"%d", pn);
        fclose(xperp);
        (*pn)++;
        xperp = fopen("perpet.out","w");
        fprintf(xperp,"%d", *pn);
        fflush(xperp);
        fclose(xperp);
}

void DoRandoms(Population *pop,int perpetual_number) /*;*/ /*funcdef - startup - DoRandoms*/
{
    FILE * rfp, *cfp;
    long fake_seeds[64];
    int file_counter,i,j,temp;
    long n;

    rfp = fopen("random.txt","r");
/*  cfp = fopen("randcnt.dat","r");
    fscanf(cfp,"%d",&file_counter);
    fclose(cfp);
*/
    file_counter = perpetual_number % 19081;
/*    printf("file_counter is %d\n",file_counter);*/
    for (i=0;i<file_counter;i++)
    {
        temp = fscanf(rfp,"%1d",&n);
        if (temp == EOF)
        {
            file_counter = -1;
            rewind(rfp);
            break;
        }
    }
/*    cfp = fopen("randcnt.dat","w");
    fprintf(cfp,"%d\n",++file_counter);
    fclose(cfp);
*/
    for (i=0;i<64;i++)
    {
        temp = fscanf(rfp,"%6ld",&(n));
/*        printf("n is %ld\n",n);
        printf("perpet_num is %ld\n",perpetual_number);
*/
        fake_seeds[i] = (long)( (((long)perpetual_number)%((long)2047))
                              * ( ((long)n) /*% 65531 */));
        if (temp == EOF)
        {
            rewind(rfp);
            fscanf(rfp,"%6d",&(n));
            fake_seeds[i] = (long)( (((long)perpetual_number)%((long)2047))
                              * ( ((long)n) /*% 65531 */));
        }
    /*    printf("fake_seed %ld\n",fake_seeds[i]);*/
    }
        if (((*pop).pop_startup_info.as_if_number) <= 0)
            ((*pop).pop_startup_info.seed)= fake_seeds[0];
        else
            ((*pop).pop_startup_info.seed)= (*pop).pop_startup_info.as_if_number;
        SetSeed(pop,((*pop).pop_startup_info.seed));
        (*pop).pop_startup_info.run_num = perpetual_number;
        if ( ((*pop).pop_startup_info.seed) < (long)0)
        {
            printf("seed is %ld\n",(*pop).pop_startup_info.seed);
            printf("error -- seed less than zero!\n");
            exit(1);
        }
        fclose(rfp);
}

void DoWelcomeMessage(void)/*;*/ /*funcdef - startup - DoWelcomeMessage*/
{
        printf("\n Welcome to DGPC\n");
        printf("\n******STARTING NEW RUN**********************\n");		
}

void  WriteInfoToOutputFile(Population *pop,              /*funcdef - startup - WriteInfoToOutputFile*/
                           char * out_put_file_name,         /*funcdef - startup - WriteInfoToOutputFile*/
                           int perpetual_number,          /*funcdef - startup - WriteInfoToOutputFile*/
                           char * timestr)/*;*/           /*funcdef - startup - WriteInfoToOutputFile*/
{
    char str[250];
    char def_file[100];
    FILE * fp;


        sprintf(out_put_file_name,"%s/P%6.6d.out",
             ((*pop).problem), perpetual_number);
        (*pop).pop_startup_info.perpetual_number = perpetual_number;
	(*pop).out_file = fopen(out_put_file_name,"w");
        if ((*pop).out_file == NULL)
        {
            printf("WARNING -- DIRECTORY BEING CREATED!\n");
            sprintf(str,"mkdir %s",(*pop).problem);
            system(str);
            (*pop).out_file = fopen(out_put_file_name,"w");
            if ((*pop).out_file == NULL)
            {
                printf("UNRECOVERABLE!!!-ERROR--EXITING!!!\n");
                exit(1);
            }
        }

        setbuf((*pop).out_file, (char *) NULL);
	/* Starting line to screen and file*/
	printf("\nStarting run %s %5.5d at time %s",
             ((*pop).problem), perpetual_number, timestr);
        fprintf((*pop).out_file,"\nStarting run %s %5.5d at time %s",
             ((*pop).problem), perpetual_number,   timestr);
	printf("\nSeed = %ld  num_individuals = %d  num_generations = %d",
             ((*pop).pop_startup_info.seed), ((*pop).pop_startup_info.num_individuals), (gpop.pop_startup_info.num_generations));
        fprintf((*pop).out_file,"\nSeed = %ld  num_individuals = %d  num_generations = %d",
             ((*pop).pop_startup_info.seed), ((*pop).pop_startup_info.num_individuals), (gpop.pop_startup_info.num_generations));
       if (((*pop).pop_startup_info.as_if_number) >0)
       {
            fprintf((*pop).out_file,"\nSeed created using as_if_number of %d\n",((*pop).pop_startup_info.as_if_number));
            fprintf(stderr,"\nSeed created using as_if_number of %d\n",((*pop).pop_startup_info.as_if_number));
       }

/*        printf("sizeof Snode is %d\n",sizeof(Snode));
        printf("Sizeof Individual is %d\n",sizeof(Individual));
        printf("sizeof branch is %d\n", sizeof(Branch));
        printf("sizeof int %d, float %d, double %d, char %d, unsigned char %d\n",
            sizeof(int), sizeof(float), sizeof(double), sizeof(char), sizeof(unsigned char));
*/
        fprintf((*pop).out_file," Sizeof Individual is %d, sizeof CompInd %d\n",sizeof(Individual),sizeof(CompInd));

        fprintf((*pop).out_file,"\nnum_primed_individuals = %d  \ncrossover_fraction_for_leaves = %f",
             ((*pop).pop_startup_info.num_primed_individuals),
             ((*pop).pop_startup_info.crossover_fraction_for_leaves));
        fprintf((*pop).out_file,"\ncrossover_fraction_for_node = %f   \nmutation_fraction = %f",
             ((*pop).pop_startup_info.crossover_fraction_for_node),
             ((*pop).pop_startup_info.mutation_fraction));
        fprintf((*pop).out_file,"\ncopy_fraction =%f, \nbranch_creation_fraction = %f",
                            ((*pop).pop_startup_info.copy_fraction),
              ((*pop).pop_startup_info.branch_creation_fraction));
        fprintf((*pop).out_file,"\nbranch_duplication_fraction =%f, \nbranch_deletion_fraction = %f",
                        ((*pop).pop_startup_info.branch_duplication_fraction),
                        ((*pop).pop_startup_info.branch_deletion_fraction));
        fprintf((*pop).out_file,"\narg__duplication_fraction =%f, \narg_deletion_fraction = %f",
                        ((*pop).pop_startup_info.arg_duplication_fraction),
                        ((*pop).pop_startup_info.arg_deletion_fraction));
        fprintf((*pop).out_file,"\nearly_cross_fract_leaves=%f  \nearly_cross_fract_node = %f\n early_mutation_fraction = %f",
             ((*pop).pop_startup_info.early_crossover_fraction_for_leaves),