コード例 #1
0
ファイル: gp.c プロジェクト: Quamber/lil-gp-eclipse
void saved_individual_gc(void) {
	int j;
	saved_ind *shp = saved_head->next;
	saved_ind *shm = saved_head;

	while (shp) {
		if (shp->refcount == 0) {
			/** found one that needs to be deleted. **/

			/* dereference its trees' ERCs and delete the trees. */
			for (j = 0; j < tree_count; ++j) {
				reference_ephem_constants(shp->ind->tr[j].data, -1);
				free_tree(shp->ind->tr + j);
			}
			FREE(shp->ind->tr);
			FREE(shp->ind);

			/* cut the record out of the linked list. */
			shm->next = shp->next;
			if (saved_tail == shp)
				saved_tail = shm;
			FREE(shp);
			/* bug fix, [email protected] */
			shp = shm->next;

			/* the refcount field of the list head (a dummy node) holds the
			 size of the list. */
			--saved_head->refcount;
		} else {
			/* move down the list. */
			shm = shp;
			shp = shp->next;
		}
	}
}
コード例 #2
0
//HJJA
population *change_population ( population *oldpop, breedphase *bp )
{
     population *newpop;
     int i, j;
     int numphases;
     double totalrate = 0.0;
     double r, r2;
     int prob_oper = atoi ( get_parameter ( "probabilistic_operators" ) );

     /* allocate the new population. */
     newpop = allocate_population ( oldpop->size );

	globaldata* g = get_globaldata();//get the lists

	if(g->bUseHFC){
		if( IsHighestActiveLevel(g->current_population)){
			 /*reproduce best guys into the new population. */
 			for(i=0;i<run_stats[0].bestn;i++){
				//printf("best %d ind\n", i);
				 duplicate_individual ( (newpop->ind)+newpop->next, run_stats[0].best[i]->ind);
				 newpop->ind[newpop->next].flags = FLAG_NONE;
				 ++(newpop->next);

				//HJJS  structure niching: mutation
				//Assumption: we think any structure mutation will create a new structure
				//for numeric mutation, we won't change the structure
				CStruct* pSt;

				int structID = newpop->ind[newpop->next].structID;
				pSt = g->pStructHash->find(structID);

				if(pSt==NULL){ //make sure,though redudency code
					  pSt = new CStruct();
					  pSt->structID = ++(g->currMaxStructID);
					  pSt->age=1;
					  pSt->lastGen=g->current_generation+1;
					  pSt->nIndividuals=0;
					  pSt->nIndNextGen=1;
					  newpop->ind[newpop->next].structID=pSt->structID;
					  g->pStructHash->insert(pSt);
				}
				else{
					if(pSt->lastGen != g->current_generation+1){//the first individual in this generation
					   pSt->age++;
					   pSt->lastGen = g->current_generation+1;
					}
					pSt->nIndNextGen++;//increase the ind no of this population
				}
				//HJJS end
			}
		}
		 //End HJJ_ELITISM

	}//End useHFC


     /* the first element of the breedphase table is a dummy -- its
				operator field stores the number of phases. */
     numphases = bp[0].operatorID;

     /* call the start method for each phase. */
     for ( i = 1; i <= numphases; ++i )
     {
          totalrate += bp[i].rate;
          if ( bp[i].operator_start )
               bp[i].operator_start ( oldpop, bp[i].data );
     }

     /* now fill the new population. */
     while ( newpop->next < newpop->size )
     {

	  /** select an operator, either stochastically or not depending on
	    the probabilistic_operators parameter. **/
          if ( prob_oper )
               r = totalrate * random_double();
          else
               r = totalrate * ((double)newpop->next/(double)newpop->size);

          r2 = bp[1].rate;
          for ( i = 1; r2 < r; )
               r2 += bp[++i].rate;
#ifdef DEBUG
          fprintf ( stderr, "picked %10.3lf; operator %d\n", r, i );
#endif


	  /* call the phase's method to do the operation. */
          if ( bp[i].operator_operate ){
               bp[i].operator_operate ( oldpop, newpop, bp[i].data );
		  }
     }

     /* call each phase's method to do cleanup. */
     for ( i = 1; i <= numphases; ++i )
     {

          if ( bp[i].operator_end )
               bp[i].operator_end ( bp[i].data );
     }

     /* mark all the ERCs referenced in the new population. */
     for ( i = 0; i < newpop->size; ++i )
          for ( j = 0; j < tree_count; ++j )
               reference_ephem_constants ( newpop->ind[i].tr[j].data, 1 );


     /* free the old population. */
     free_population ( oldpop );  //Bug when do reproduction ?


     return ( newpop );
     
}
コード例 #3
0
ファイル: gp.c プロジェクト: Quamber/lil-gp-eclipse
void calculate_pop_stats(popstats *s, population *pop, int gen, int subpop) {
	int i, j, k, l;
	int b;
	saved_ind *shp;
	individual **temp;

	/* allocate a list of the top N individuals. */
	s->best = (saved_ind **) MALLOC(s->bestn * sizeof(saved_ind *));
	temp = (individual **) MALLOC((s->bestn + 1) * sizeof(individual *));

	s->size = pop->size;

	/** this is all pretty obvious -- set all the max and min values to the
	 first individual's values, then go through the population looking for
	 things that are bigger/smaller/better/worse/etc. **/

	s->maxnodes = s->minnodes = s->totalnodes = s->bestnodes = s->worstnodes =
			individual_size(pop->ind + 0);
	s->maxdepth = s->mindepth = s->totaldepth = s->bestdepth = s->worstdepth =
			individual_depth(pop->ind + 0);
	s->maxhits = s->minhits = s->totalhits = s->besthits = s->worsthits =
			pop->ind[0].hits;
	s->bestfit = s->worstfit = s->totalfit = pop->ind[0].a_fitness;
	temp[0] = pop->ind;
	b = 1;
	s->bestgen = s->worstgen = gen;
	s->bestpop = s->worstpop = subpop;

	for (i = 1; i < s->size; ++i) {
		j = individual_size(pop->ind + i);
		s->totalnodes += j;
		if (j < s->minnodes)
			s->minnodes = j;
		if (j > s->maxnodes)
			s->maxnodes = j;

		k = individual_depth(pop->ind + i);
		s->totaldepth += k;
		if (k < s->mindepth)
			s->mindepth = k;
		if (k > s->maxdepth)
			s->maxdepth = k;

		l = pop->ind[i].hits;
		s->totalhits += l;
		if (l < s->minhits)
			s->minhits = l;
		if (l > s->maxhits)
			s->maxhits = l;

		s->totalfit += pop->ind[i].a_fitness;
		if (pop->ind[i].a_fitness > s->bestfit) {
			s->bestfit = pop->ind[i].a_fitness;
			s->bestnodes = j;
			s->bestdepth = k;
			s->besthits = l;
		} else if (pop->ind[i].a_fitness < s->worstfit) {
			s->worstfit = pop->ind[i].a_fitness;
			s->worstnodes = j;
			s->worstdepth = k;
			s->worsthits = l;
		}

		/** insert the current individual into the top N list
		 (if it belongs there). **/

		for (j = b; j > 0; --j) {
			if (pop->ind[i].a_fitness < temp[j - 1]->a_fitness)
				break;
			temp[j] = temp[j - 1];
		}
		if (j < s->bestn)
			temp[j] = pop->ind + i;
		if (b < s->bestn)
			++b;
	}

	/** now save copies of the individuals in the "temp" list **/
	for (i = 0; i < b; ++i) {
		shp = (saved_ind *) MALLOC(sizeof(saved_ind));
		shp->ind = (individual *) MALLOC(sizeof(individual));
		shp->ind->tr = (tree *) MALLOC(tree_count * sizeof(tree));
		duplicate_individual(shp->ind, temp[i]);
		for (j = 0; j < tree_count; ++j)
			reference_ephem_constants(shp->ind->tr[j].data, 1);
		shp->refcount = 1;
		shp->next = NULL;

		saved_tail->next = shp;
		saved_tail = shp;
		++saved_head->refcount;

		s->best[i] = shp;
	}

#ifdef DEBUG
	printf ( "the best list is:\n" );
	for ( j = 0; j < s->bestn; ++j )
	printf ( "     %08x  %lf\n", s->best[j], s->best[j]->ind->a_fitness );
#endif

	FREE(temp);

}