gpshared.c

遗传规划工具

/*======================================================================+
| PGPC: Parallel Genetic Programming in C                               |
| (c) 1994 Genetic Algorithm Technology Corp. all rights reserved       |
|   written by David Andre                                              |
+======================================================================*/
/*======================================================================+
| FILE: gpshared.c                                                      |
| DESCRIPTION: Contains code required both in the boss node and the     |
| breeder nodes, such as randomizers and the like.  May disappear when  |
| out-of sample fittnes cases are allowed.                              |
|                                                                       |
| REVISIONS:                                                            |
| Jan 24, 1995:  Works as of today, no known bugs.                      |
| Mar 21, 1995:  Changed and added Randu, PM randomizers, added         |
|                fitness case randomizers                               |
+======================================================================*/


#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "gp.h"
#include <math.h>
#include "proto.h"
#include "time.h"
#ifdef __BORLANDC__
#include "gpi_stub.h"
#else
/*#include <iocntrl.h>
#include <process.h>
#include <channel.h>
#include <semaphor.h>
#include "mncommon.h"
#include "mnproto.h"
#include "gpi.h"*/
#endif
#ifdef _ICC
	 #include <process.h>
#endif

#define RANDU_MODER     2147483648  /*  2^32   */
#define PM_MODER        2147483647  /*  2^32-1 */
#define RANDU_CONSTANT  65539
#define PM_CONSTANT     16807

#define MY_MODER    2147483647

static unsigned long      g_my_state;
static unsigned long      g_constant;
static unsigned long      g_mod_num;

static unsigned long      randu_constant;
static unsigned long      pm_constant;

static  char g_str[256];

unsigned long MyRand(void)/*;*/ /*funcdef*/
{
    return g_my_state = ((g_my_state * g_constant) % (MY_MODER));
}

unsigned long MyMaxRand(void)/*;*/ /*funcdef*/
{
	 return (unsigned long) (MY_MODER);
}

unsigned long MySrand(unsigned long my_seed)/*;*/ /*funcdef*/
{
    g_constant = (unsigned long int)pow(7.0,5.0);
    return (g_my_state = my_seed);
}

unsigned long GetMyRand(void)/*;*/ /*funcdef*/
{
    return(g_my_state);
}

unsigned long PM_Rand(void)/*;*/ /*funcdef*/
{
    g_my_state = ((g_my_state * PM_CONSTANT) % (PM_MODER));
    return (g_my_state);
}

unsigned long PM_MaxRand(void)/*;*/ /*funcdef*/
{
    return (unsigned long) (PM_MODER);
}

unsigned long PM_Srand(unsigned long my_seed)/*;*/ /*funcdef*/
{
    g_my_state = my_seed;
    return (g_my_state);
}

unsigned long GetPMRand(void)
{
    return(g_my_state);
}

unsigned long Randu_Rand(void)/*;*/ /*funcdef*/
{
    return g_my_state = ((g_my_state * RANDU_CONSTANT) % (RANDU_MODER));
}

unsigned long Randu_MaxRand(void)/*;*/ /*funcdef*/
{
    return (unsigned long) (RANDU_MODER);
}

unsigned long Randu_Srand(unsigned long my_seed)/*;*/ /*funcdef*/
{
    return (g_my_state = my_seed);
}

unsigned long GetRanduRand(void)
{
    return(g_my_state);
}



/*---------------------------------------------*/


void SetSeed(Population *pop,  unsigned long s  )/*;*/ /*funcdef - dgpc - SetSeed*/
{
  ((*pop).pop_startup_info.seed) = (long)s;
  /* new code */
  SRAND((signed long)s);
}

unsigned long GetSeed(Population * pop)/*;*/ /*funcdef - dgpc - GetSeed*/
{
  return ((*pop).pop_startup_info.seed);
}

unsigned long GetSystemSeed(void)
{
	long temp;
	temp = rand();
	srand(temp);
	return(temp);
}


float GaussianNoise(float mean, float sigma )/*;*/ /*funcdef - dgpc - GaussianNoise*/
{
  float		gauss;
  static int gaussian_noise_toggle;
  static float  gaussian_noise_uniform1, gaussian_noise_uniform2;
  static float  gaussian_noise_temp;


  if (gaussian_noise_toggle) {
    gaussian_noise_uniform1 = (RandomFloat( (float) 1.0));
    gaussian_noise_uniform2 = (RandomFloat( (float) 1.0));
    gaussian_noise_temp =
		  (float) sqrt(-2.0 * log((double)gaussian_noise_uniform1));
    gauss = gaussian_noise_temp *
      (float)cos((float)(2.0*3.14159*gaussian_noise_uniform2));
  }
  else {
    gauss = gaussian_noise_temp *
      (float)sin((float)(2.0*3.14159*gaussian_noise_uniform2));
  }
  gaussian_noise_toggle = ! gaussian_noise_toggle;
  return mean + (sigma * gauss);
}

float ParkMillerRandomizer(void)/*;*/ /*funcdef - dgpc - ParkMillerRandomizer*/
{
  float retval;


  retval = (float) (((float)(double) RAND()) / ((float)(double) DRAND_MAX));
  return retval;
}

float RandomFloat( float f  )/*;*/  /*	 0 <=  RandomFloat() < f  */ /*funcdef - dgpc - RandomFloat*/
{
  float	retval;

  retval = (f*((float) 1.0-ParkMillerRandomizer()));

  return retval;

}

int RandomInt(   int i  )/*;*/    /* 0 <= RandomInt() < i   */ /*funcdef - dgpc - RandomInt*/
{
  int	retval;

  if (i==0) return(0);

 retval = ((int) fabs(((double)i *  (double)RandomFloat((float) 1.0)))) % i;

  return retval;
}

float gpRandomFloat( float f  )/*;*/  /*	 0 <=  RandomFloat() < f  */ /*funcdef - dgpc - RandomFloat*/
{
  float	retval;

  retval = (f*((float) 1.0-ParkMillerRandomizer()));

  return retval;

}

int gpRandomInt(   int i  )/*;*/    /* 0 <= RandomInt() < i   */ /*funcdef - dgpc - gpRandomInt*/
{
  int	retval;

  if (i==0) return(0);

 retval = ((int) fabs(((double)i *  (double)gpRandomFloat((float) 1.0)))) % i;

  return retval;
}


float FitParkMillerRandomizer(void)/*;*/ /*funcdef - dgpc - ParkMillerRandomizer*/
{
  float retval;


  retval = (float) (((float)(double) FRAND()) / ((float)(double) FDRAND_MAX));
  return retval;
}

float FitRandomFloat( float f  )/*;*/  /*	 0 <=  RandomFloat() < f  */ /*funcdef - dgpc - RandomFloat*/
{
  float	retval;

  retval = (f*((float) 1.0-FitParkMillerRandomizer()));

  return retval;

}

int FitRandomInt(   int i  )/*;*/    /* 0 <= RandomInt() < i   */ /*funcdef - dgpc - RandomInt*/
{
  int	retval;

  if (i==0) return(0);

 retval = ((int) fabs(((double)i *  (double)FitRandomFloat((float) 1.0)))) % i;

  return retval;
}



void CreateIndividual(Individual * ind)/*;*/ /*funcdef - dgpc - CreateIndividual*/
{
	int i,j;
	int bnum;
	int codep;
        int bsize;
		
	i=0;bnum=0;codep=0;               	
	for (j=0;j<NUM_RPBS;j++)
	{
		 bsize = GetBranchSize(bnum);
		ind->rpbs[j].branchnum = bnum;
		ind->rpbs[j].num_nodes  = bsize;
		ind->rpbs[j].tree = &(ind->code[codep]);
		ind->rpbs[j].ind  = ind;
		bnum++;
                codep +=bsize;
	}
	for (j=0;j<MAX_NUM_ADFS;j++)
	{
					 bsize = GetBranchSize(bnum);
		ind->adfs[j].branchnum = bnum;
		ind->adfs[j].num_nodes  = bsize;
		ind->adfs[j].tree = &(ind->code[codep]);
                ind->adfs[j].ind  = ind;
		bnum++;
                codep +=bsize;
	}
	i=i;
}


void CopyIndividual(Individual * ind1, Individual * ind2)/*;*/ /*funcdef - dgpc - CopyIndividual*/
{
	int i,j;

		
        CreateIndividual(ind2);
        for (i=0;i<MAX_NUM_NODES_PER_DUDE;i++)
        {
            ind2->code[i].opcode = ind1->code[i].opcode;
            ind2->code[i].jump   = ind1->code[i].jump;
        }
	for (i=0;i< NUM_RPBS; i++)
	{
		for (j=0;j<TOTAL_NUMBER_OF_FUNCTIONS;j++)
			ind2->rpbs[i].function_vector[j] = ind1->rpbs[i].function_vector[j];
	}
	for (i=0;i< MAX_NUM_ADFS; i++)
	{
		for (j=0;j<TOTAL_NUMBER_OF_FUNCTIONS;j++)
			ind2->adfs[i].function_vector[j] = ind1->adfs[i].function_vector[j];
	}
	ind2->s_fitness = ind1->s_fitness;
	ind2->hits = ind1->hits;
        ind2->beauty = ind1->beauty;
	ind2->current_number_of_adfs = ind1->current_number_of_adfs;
	for (i=0;i<MAX_NUM_ADFS;i++)
		ind2->adf_arity[i] = ind1->adf_arity[i];
       #if (USE_MULTI_TYPED_ADFS)
        for (i=0;i<MAX_NUM_ADFS;i++)
            ind2->adf_type[i] = ind1->adf_type[i];
       #endif
#if (DO_POOR_WHITE_TRASH_AUDIT)
        for (i=0;i<NUM_OPS_TO_KEEP;i++)
            ind2->cy_num_of_ops[i] = ind1->cy_num_of_ops[i];
        for (i=0;i<NUM_OPS_TO_KEEP;i++)
            ind2->op_list[i] = ind1->op_list[i];
        for (i=0;i<NUM_OPS_TO_KEEP;i++)
            ind2->fit_at_op[i] = ind1->fit_at_op[i];
        ind2->num_ops_done = ind1->num_ops_done;

#endif

}


/*-----------------------------------------------------------------------------*/		

void CopyTree(Branch * br1, Branch * br2)/*;*/ /*copies br1 into br2*/ /*funcdef - dgpc - CopyTree*/
{
int i;
	 for (i=0;i<br1->num_nodes;i++)	
    {
    br2->tree[i].opcode = br1->tree[i].opcode;
    br2->tree[i].jump   = br1->tree[i].jump;
    }
}


int ChooseRandomFunction(Population * pop,int kind,Branch *br) /*funcdef*/
{
/* kind == 0 means leaf node*/
/* kind == 1 means internal node*/
/* kind == 2 means any node */
    int i,temp;
    int sum;
    sum=0;
    for (i=0;i<TOTAL_NUMBER_OF_FUNCTIONS;i++)
    {
        if (kind == 0)
        {
            if (_function_arity(i) == 0)
                sum+= (*pop).func_table[i].weight;
        }
        else if (kind == 1)
        {
            if (_function_arity(i) > 0)
                sum+= (*pop).func_table[i].weight;
        }
        else
                sum+= (*pop).func_table[i].weight;
    }
    temp = RandomInt(sum);
    i=0;
    sum=0;
    while(i < TOTAL_NUMBER_OF_FUNCTIONS)
    {
        if (kind == 0)
        {
            if (_function_arity(i) == 0)
                sum+= (*pop).func_table[i].weight;
        }
        else if (kind == 1)
        {
            if (_function_arity(i) > 0)
                sum+= (*pop).func_table[i].weight;
        }
        else
                sum+= (*pop).func_table[i].weight;

        if (temp < sum)
            return(i);
        i++;
    }
	 gpi_SendError("Error in choose random function\n");
	 return(-1);
}


int ChooseRandomCSSFunction(Population * pop,int kind,Branch *br,int * fvector) /*funcdef*/
{
/* kind == 0 means leaf node*/
/* kind == 1 means internal node*/
/* kind == 2 means any node */
    int i,temp;
    int sum;
    sum=0;
    for (i=0;i<TOTAL_NUMBER_OF_FUNCTIONS;i++)
    {
        if (kind == 0)
        {
            if (fvector[i] == 0)
                sum+= (*pop).func_table[i].weight;
        }
        else if (kind == 1)
        {
            if (fvector[i] > 0)
                sum+= (*pop).func_table[i].weight;
        }
        else if (fvector[i] > -1)
                sum+= (*pop).func_table[i].weight;
    }
    temp = RandomInt(sum);
    i=0;
    sum=0;
    while(i < TOTAL_NUMBER_OF_FUNCTIONS)
    {
        if (kind == 0)
        {
            if (fvector[i] == 0)
                sum+= (*pop).func_table[i].weight;
        }
        else if (kind == 1)
        {
            if (fvector[i] > 0)
                sum+= (*pop).func_table[i].weight;
        }
        else if (fvector[i] > -1)
                sum+= (*pop).func_table[i].weight;

        if (temp < sum)
            return(i);
        i++;
    }
	 gpi_SendError("Error in choose random css function\n");
	 return(-1);
}



     		


void init_macro(Branch *br)/*;*/ /*funcdef*/
{
(br->ind->index_ptr)++;
}



void skip_subtree(Branch *br)/*;*//*funcdef*/
{
(br->ind->index_ptr) = TraverseSubtree(br,(br->ind->index_ptr));
(br->ind->index_ptr)++;
}


int GetFuncNumber(char * str,Population * pop)
{
int i;
    for (i=0;i<TOTAL_NUMBER_OF_FUNCTIONS;i++)
    {
        if (!strcmp(str,(*pop).func_table[i].print_name))
            return(i);

    }
    sprintf(g_str,"Error!  No function matches %s\n",str);
	 gpi_SendError(g_str);
	 exit(1);
    return(-1);
}


GTYPE EvalBranch(Branch *br,Population *pop) /*;*/ /*funcdef - gpkernel - EvalBranch*/
{
int temp;
GTYPE temp2;

temp = br->ind->index_ptr;
br->ind->index_ptr  =0;
temp2 = _eval_subtree(br,pop);
br->ind->index_ptr  =temp;
return(temp2);

}


/*----------------------------------------------------*/
void CopyFVector(int * fvector_from, int * fvector_to)
{
    int i;
    for (i=0;i<TOTAL_NUMBER_OF_FUNCTIONS;i++)
    {
       fvector_to[i] = fvector_from[i];
    }
}


Branch * GetRightBranch(Individual * dude, int bnum)/*;*/ /*funcdef - dgpc - GetRightBranch */
{
	if (bnum < NUM_RPBS)
		return( &(dude->rpbs[bnum]) );
	else
		return( &(dude->adfs[bnum - NUM_RPBS]) );
}