getparams.c

一个完整的C语言遗传程序包

  )
#else

VOID readparams(pop,i,f)
  pop_struct 	*pop;
  int		i;
  FILE		*f;
#endif
{
  char	buf[132], name[132], val[132];
  unsigned long seed;
  FILE *tmp;

  while (fgets(buf,132,f) != (char *)NULL) {
    if (buf[0] == '#') continue;
    sscanf(buf,"%s = %s", name, val);
    if (!strcasecmp("seed",name)) {
      sscanf(val,"%ld",&seed);
      set_seed(seed);
    } else if (!strcasecmp("steady_state",name)) {
      sscanf(val,"%d",&(pop[i].steady_state));
    } else if (!strcasecmp("population_size",name)) {
      sscanf(val,"%d",&(pop[i].population_size));
    } else if (!strcasecmp("load_from_file",name)) {
      sscanf(val,"%s",  pop[i].load_from_file);
      if ((tmp=fopen(pop[i].load_from_file,"r")) == (FILE *)NULL) {
	fprintf(stderr,"Error: load_from_file not found: %s\n",
		pop[i].load_from_file);
	exit(1);
      }
      else {
	fclose(tmp);
      }
    } else if (!strcasecmp("checkpoint_frequency",name)) {
      sscanf(val,"%d",&(CHECKPOINT_FREQUENCY));
    } else if (!strcasecmp("max_depth_for_new_trees",name)) {
      sscanf(val,"%d",&(pop[i].max_depth_for_new_trees));
    } else if (!strcasecmp("max_depth_after_crossover",name)) {
      sscanf(val,"%d",&(pop[i].max_depth_after_crossover));
    } else if (!strcasecmp("max_mutant_depth",name)) {
      sscanf(val,"%d",&(pop[i].max_mutant_depth));
    } else if (!strcasecmp("grow_method",name)) {
      if (!strcasecmp(val,"FULL")) {
	pop[i].grow_method = FULL;
      } else if (!strcasecmp(val,"GROW")) {
	pop[i].grow_method = GROW;
      } else if (!strcasecmp(val,"RAMPED")) {
	pop[i].grow_method = RAMPED;
      } else {
	fprintf(stderr,"readparams(): bad grow_method val name %s\n",val);
      }
    } else if (!strcasecmp("selection_method",name)) {
      if (!strcasecmp(val,"TOURNAMENT")) {
	pop[i].selection_method = TOURNAMENT;
      } else if (!strcasecmp(val,"OVERSELECT")) {
	pop[i].selection_method = OVERSELECT;
      } else if (!strcasecmp(val,"FITNESSPROP")) {
	pop[i].selection_method = FITNESSPROP;
      } else {
	fprintf(stderr,"readparams(): bad selection_method val name %s\n",val);
      }
    } else if (!strcasecmp("tournament_K",name)) {
      sscanf(val,"%d",&(pop[i].tournament_K));
    } else if (!strcasecmp("deme_search_radius_sigma",name)) {
      sscanf(val,"%f",&(pop[i].deme_search_radius_sigma));
    } else if (!strcasecmp("crossover_func_pt_fraction",name)) {
      sscanf(val,"%f",&(pop[i].crossover_func_pt_fraction));
    } else if (!strcasecmp("crossover_any_pt_fraction",name)) {
      sscanf(val,"%f",&(pop[i].crossover_any_pt_fraction));
    } else if (!strcasecmp("fitness_prop_repro_fraction",name)) {
      sscanf(val,"%f",&(pop[i].fitness_prop_repro_fraction));
    } else if (!strcasecmp("parsimony_factor",name)) {
      sscanf(val,"%f",&(pop[i].parsimony_factor));
    } else if (!strcmp("_END_OF_PARAMETERS_POPULATION",name)) {
      int popnum;
      sscanf(val,"%d",&popnum);
      if (popnum != i) {
	fprintf(stderr,"Warning: readparams() possible population mismatch\n");
      }
      break;
    } else {
      fprintf(stderr,"readparams(): bad param name %s\n",name);
    }
  }
}

#ifdef ANSI_FUNC

VOID writeparams(
  pop_struct 	*pop,
  int		p,
  FILE 		*f
  )
#else

VOID writeparams(pop,p,f)
  pop_struct 	*pop;
  int		p;
  FILE		*f;
#endif
{
  fprintf(f, "seed = %ld\n",                    get_seed());
  fprintf(f,"checkpoint_frequency = %d\n",	CHECKPOINT_FREQUENCY);
  fprintf(f,"population_size = %d\n",		pop[p].population_size);
  fprintf(f,"steady_state = %d\n",		pop[p].steady_state);
  if (pop[p].load_from_file[0] != '\0') {
    fprintf(f,"load_from_file = %s\n", 		pop[p].load_from_file);
  }
  fprintf(f,"max_depth_for_new_trees = %d\n",	pop[p].max_depth_for_new_trees);
  fprintf(f,"max_depth_after_crossover = %d\n",	pop[p].max_depth_after_crossover);
  fprintf(f,"max_mutant_depth = %d\n",		pop[p].max_mutant_depth);
  fprintf(f,"grow_method = ");
  switch(pop[p].grow_method) {
  case FULL:
    fprintf(f,"FULL\n");
    break;
  case GROW:
    fprintf(f,"GROW\n");
    break;
  case RAMPED:
    fprintf(f,"RAMPED\n");
    break;
  }
  fprintf(f,"selection_method = ");
  switch(pop[p].selection_method) {
  case TOURNAMENT:
    fprintf(f,"TOURNAMENT\n");
    break;
  case OVERSELECT:
    fprintf(f,"OVERSELECT\n");
    break;
  case FITNESSPROP:
    fprintf(f,"FITNESSPROP\n");
  }
  fprintf(f,"tournament_K = %d\n",
	  pop[p].tournament_K);
  fprintf(f,"deme_search_radius_sigma = %f\n",
	  pop[p].deme_search_radius_sigma);
  fprintf(f,"crossover_func_pt_fraction = %f\n",
	  pop[p].crossover_func_pt_fraction);
  fprintf(f,"crossover_any_pt_fraction = %f\n",
	  pop[p].crossover_any_pt_fraction);
  fprintf(f,"fitness_prop_repro_fraction = %f\n",
	  pop[p].fitness_prop_repro_fraction);
  fprintf(f,"parsimony_factor = %f\n",
	  pop[p].parsimony_factor);
}


#ifdef ANSI_FUNC
void checkpoint (
  int           numpops,
  int           numgens,
  int           demes,
  int           demerows,
  int           demecols,
  pop_struct 	*pop,
  int		g
  )
#else
VOID checkpoint(numpops,numgens,demes,demerows,demecols,pop,g)
  int           numpops;
  int           numgens;
  int           demes;
  int           demerows;
  int           demecols;
  pop_struct	*pop;
  int		g;
#endif
{
  int	i, p;
  char  ckptfile[256], cmd_buf[256];
  FILE	*cf;

  sprintf(ckptfile,"gpc_%ld_%d.ckpt",gethostid(),getpid());
  
  cf = fopen(ckptfile,"w");

  fprintf(cf, "checkpoint_for_generation =  %d\n", g);
  fprintf(cf, "random_seed = %ld\n",get_seed());
  fprintf(cf, "number_of_populations = %d\n",numpops);
  fprintf(cf, "number_of_generations = %d\n",numgens);
  fprintf(cf, "demes = %d\n",demes);
  fprintf(cf, "number_of_deme_rows = %d\n",demerows);
  fprintf(cf, "number_of_deme_columns = %d\n",demecols);
  fprintf(cf, "gaussian_noise_uniform1 = %22.20f\n",gaussian_noise_uniform1);
  fprintf(cf, "gaussian_noise_uniform2 = %22.20f\n",gaussian_noise_uniform2);
  fprintf(cf, "gaussian_noise_temp = %22.20f\n",gaussian_noise_temp);
  fprintf(cf, "gaussian_noise_toggle = %d\n",gaussian_noise_toggle);

  fprintf(cf,"\n");

  for (p=0; p<numpops; p++) {
    writeparams(pop, p, cf);
    fprintf(cf,"_END_OF_PARAMETERS_POPULATION = %d\n",p);
  }

  for (p=0; p<numpops; p++) {
    fprintf(cf,"_START_OF_POPULATION_ = %d\n",p);
    for (i=0; i<pop[p].population_size; i++) {
      write_tree(pop, pop[p].population[i], pop[p].ckpt_format, cf);
    }
  }

  for (p=0; p<numpops; p++) {
    fprintf(cf, "best_of_run_fitness = %22.20f\n",pop[p].best_of_run_fitness);
    fprintf(cf, "best_of_run_gen = %d\n",pop[p].best_of_run_gen);
    write_tree(pop, pop[p].best_of_run, pop[p].ckpt_format, cf);
  }

  fclose(cf);
  sprintf(cmd_buf,"%s %s &",COMPRESS,ckptfile);
  system(cmd_buf);
}


#ifdef ANSI_FUNC
void recover_params (
  FILE		*cf,
  int           *numpops,
  int           *numgens,
  int           *demes,
  int           *demerows,
  int           *demecols,
  pop_struct	**pop,
  pop_struct    ****grid,
  int		*g
  )
#else
VOID recover_params (cf,numpops,numgens,demes,demerows,demecols,pop,grid,g)
  FILE		*cf;
  int           *numpops;
  int           *numgens;
  int           *demes;
  int           *demerows;
  int           *demecols;
  pop_struct	**pop;
  pop_struct    ****grid;
  int		*g;
#endif
{
  int 	p;
  int	i, j;
  unsigned long 	seed;
  char	buf[132], name[132], val[132];

  fscanf(cf,"%s = %s", name, val);
  if (!strcmp("checkpoint_for_generation",name)) { 
    sscanf(val, "%d", g);
  }
  else {
    fprintf(stderr,"Error reading checkpoint file.\n");
  }
  fscanf(cf,"%s = %s", name, val);
  if (!strcmp("random_seed",name)) { 
    sscanf(val, "%ld",&seed);
  }
  else {
    fprintf(stderr,"Error reading checkpoint file.\n");
  }
  fscanf(cf,"%s = %s", name, val);
  if (!strcmp("number_of_populations",name)) { 
    sscanf(val, "%d",numpops);
  }
  else {
    fprintf(stderr,"Error reading checkpoint file.\n");
  }
  fscanf(cf,"%s = %s", name, val);
  if (!strcmp("number_of_generations",name)) { 
    sscanf(val, "%d",numgens);
  }
  else {
    fprintf(stderr,"Error reading checkpoint file.\n");
  }
  fscanf(cf,"%s = %s", name, val);
  if (!strcmp("demes",name)) { 
    sscanf(val, "%d",demes);
  }
  else {
    fprintf(stderr,"Error reading checkpoint file.\n");
  }
  fscanf(cf,"%s = %s", name, val);
  if (!strcmp("number_of_deme_rows",name)) { 
    sscanf(val, "%d",demerows);
  }
  else {
    fprintf(stderr,"Error reading checkpoint file.\n");
  }
  fscanf(cf,"%s = %s", name, val);
  if (!strcmp("number_of_deme_columns",name)) { 
    sscanf(val, "%d",demecols);
  }
  else {
    fprintf(stderr,"Error reading checkpoint file.\n");
  }
  fscanf(cf,"%s = %s", name, val);
  if (!strcmp("gaussian_noise_uniform1",name)) { 
    sscanf(val, "%f",&gaussian_noise_uniform1);
  }
  else {
    fprintf(stderr,"Error reading checkpoint file.\n");
  }
  fscanf(cf,"%s = %s", name, val);
  if (!strcmp("gaussian_noise_uniform2",name)) { 
    sscanf(val, "%f",&gaussian_noise_uniform2);
  }
  else {
    fprintf(stderr,"Error reading checkpoint file.\n");
  }
  fscanf(cf,"%s = %s", name, val);
  if (!strcmp("gaussian_noise_temp",name)) { 
    sscanf(val, "%f",&gaussian_noise_temp);
  }
  else {
    fprintf(stderr,"Error reading checkpoint file.\n");
  }
  fscanf(cf,"%s = %s", name, val);
  if (!strcmp("gaussian_noise_toggle",name)) { 
    sscanf(val, "%d",&gaussian_noise_toggle);
  }
  else {
    fprintf(stderr,"Error reading checkpoint file.\n");
  }

  fscanf(cf,"\n");
  
  *pop = (pop_struct *) malloc(*numpops*sizeof(pop_struct));
  if (*demes) {
    *grid = (pop_struct ***) malloc2(*demerows,*demecols*sizeof(pop_struct *));
    for (i=0;i<*demerows;i++) {
      for (j=0;j<*demecols;j++) {
	(*grid)[i][j] = (pop_struct *) malloc(*numpops*sizeof(pop_struct));
      }
    }
  }

  for (p = 0; p < *numpops; p++) {
    (*pop)[p].load_from_file = (char *) malloc(132*sizeof(char));
    readparams(*pop, p, cf);
    (*pop)[p].load_from_file[0] = '\0'; /* don't load from file upon recovery */
  }

  set_seed(seed);

}