queue2.cc

标准的GP源代码,由Andy Singleton维护

				    }
				break;
			}//end switch
	      }
	calls [ tree ]--;

	Arg1   = save_arg1;
	Arg2   = save_arg2;
	last_var_used = save_var_used;

	return result;

}//end calleval

OPDEF(MakenullEval) {return calleval (0,makenull);}
OPDEF(FrontEval)    {return calleval (0,front);}
OPDEF(DequeueEval)  {return calleval (0,dequeue);}
OPDEF(EnqueueEval)  {return calleval (1,enqueue);}
OPDEF(EmptyEval)    {return calleval (0,empty);}
OPDEF(Adf1Eval)     {return calleval (1,adf1,&adf1_cache);}
OPDEF(Adf2Eval)     {return calleval (2,adf2);}

//**************************************************************************
///////////////////////// PROBLEM definition


void queue::AddF1 (int t, Function* f )
{
AddF(f);
addtofuncbag(t, f);
}

void queue::AddFbar1 (int exclude_tree, Function* f )
{
AddF(f);
for ( int i = 0; i < NUM_TREES; i++ )
	{if ( i != exclude_tree) addtofuncbag(i, f);};
}

void queue::AddF2 (int t1, int t2, Function* f )
{
AddF(f);
addtofuncbag(t1, f);
addtofuncbag(t2, f);
}

void queue::AddF3 (int t1, int t2, int t3, Function* f )
{
AddF(f);
addtofuncbag(t1, f);
addtofuncbag(t2, f);
addtofuncbag(t3, f);
}

void queue::AddFmain (Function* f )
{
AddFbar1(adf1, f);
}

void queue::AddFall (Function* f )
{
AddFmain(f);
addtofuncbag(adf1, f);
}

queue::queue(ChromeParams* p) : Problem()
{
	assert ( NUM_TREES >= adf1+1);

	AddF(new ConstFunc(0));    // REQUIRED as function 0

	// Add some standard primitives
	AddFall(new AddFunc(100));
	AddFall(new SubFunc(100));

	AddFall(new Function(2,0,100,Prog2Eval,"PROG2"));
//	AddFall(new Function(3,0,100,Prog3Eval,"PROG3"));
	AddFall(new Function(2,0,100,Qrog2Eval,"QROG2"));
//	AddFall(new Function(3,0,100,Qrog3Eval,"QROG3"));

	// Add the problem specific primitives
	AddFall(new Function(0,0,100,zeroEval,"0"));
	AddFall(new Function(0,0,100,oneEval,"1"));
	AddFall(new Function(0,0,100,MaxEval,"max"));
	AddFall(new Function(2,0,100,modEval,"mod"));

	AddF2(enqueue, adf1, new Function(0,0,100,Arg1Eval,"arg1"));
//	AddFx(new Function(0,0,100,Arg2Eval,"arg2"));
	AddFmain(new Function(0,0,100,Aux1Eval,"aux1"));
//	AddF3(makenull, dequeue, enqueue,
//              new Function(0,0,100,inc_Aux1Eval,"Inc_Aux1"));
//	AddF3(makenull, dequeue, enqueue,
//              new Function(0,0,100,Minc_Aux1Eval,"MInc1"));
//	AddFmain(new Function(0,0,100,dec_Aux1Eval,"Dec_Aux1"));
	AddFmain(new Function(0,0,100,Aux2Eval,"aux2"));
//	AddF3(makenull, dequeue, enqueue,
//              new Function(0,0,100,inc_Aux2Eval,"Inc_Aux2"));
//	AddF3(makenull, dequeue, enqueue,
//              new Function(0,0,100,Minc_Aux2Eval,"MInc2"));
//	AddFmain(new Function(0,0,100,dec_Aux2Eval,"Dec_Aux2"));
//	AddFmain(new Function(0,0,100,Aux3Eval,"aux3"));
//	AddF3(makenull, dequeue, enqueue,
//              new Function(0,0,100,inc_Aux3Eval,"Inc_Aux3"));
//	AddF3(makenull, dequeue, enqueue,
//              new Function(0,0,100,Minc_Aux3Eval,"MInc3"));
//	AddF3(makenull, dequeue, enqueue,
//              new Function(0,0,100,dec_Aux3Eval,"Dec_Aux3"));

	AddFmain(new Function(1,0,100,readEval,"read"));
	AddF3(makenull, dequeue, enqueue,
              new Function(2,0,100,writeEval,"write"));
//	AddFx(new Function(1,0,100,write_Aux1Eval,"Write_Aux1"));
//	AddFx(new Function(1,0,100,write_Aux2Eval,"Write_Aux2"));
	AddF1(makenull, new Function(1,0,100,set_Aux1Eval,"Set_Aux1"));
	AddF1(makenull, new Function(1,0,100,set_Aux2Eval,"Set_Aux2"));
//	AddF1(makenull, new Function(1,0,100,set_Aux3Eval,"Set_Aux3"));

//	AddF(new Function(0,0,100,MakenullEval,"Makenull"));
	AddF1(dequeue,new Function(0,0,100,FrontEval,"Front"));
//	AddF(new Function(0,0,100,DequeueEval,"Dequeue"));
//	AddF(new Function(1,0,100,EnqueueEval,"Enqueue"));
//	AddF(new Function(0,0,100,EmptyEval,"Empty"));
	AddF2(dequeue, enqueue, new Function(1,0,100,Adf1Eval,"Adf1"));
//	AddF(new Function(2,0,100,Adf2Eval,"Adf2"));

	// Set some defualt parameters

	p->params[pMaxExpr]=250;	// Nb hold NUM_TREES trees
	p->params[pRepeatEval]=0;	// Dont test again if copy chrome
	p->params[pMuteShrinkWt]=0;	// No shrink mutation
	p->params[pMuteWt]=0;	        // No muation
	p->params[pCrossWt]=90;         // Use Koza value
	p->params[pMuteRate]=0;         // No mutations
	p->params[pAnnealCrossWt]=0;	// No annealing
	p->params[pAnnealMuteWt]=0;
	p->params[pTournSize]=4;	// try and see
	p->params[pKillTourn]=4;	// try and see
	p->params[pMateRadius]=0;	// whole population
	p->params[pMaxAge]=0;     	// no age limit
//	p->params[pFitnessCases]=;	// ?
	p->params[pPopSize]=1000;	// Population size
	p->params[pPopSize]=50000;	// Max number individuals to generate

	ifstream gpParams ("gp.ini");
	if ( gpParams )
	     { p->Load(gpParams);
	       gpParams.close();
             }
	else 
		cerr << "Could not open gp.ini, using defaults\n";

	// If you need to load problem specific data for evaluation
	// Or load an environment (a map, a scenario)
	// Do it here
}
//store for test cases

int first_test = 0;

const int first_test_sequence = 1;
int test[Max_tests];
retval argument[Max_tests];
retval ans[Max_tests];

int fron, rear;
retval correct_queue [test_queue_limit+1];

int addone(int i) {return (i + 1 )% test_queue_limit;}
BOOL set_answer (int i)
{
ans [i] = 0;
argument [i] = 0;

switch(test[i])
{
 case makenull:
	fron = 0;
	rear = test_queue_limit - 1;
	break;

 case front:
	if (addone(rear) == fron )
		return FALSE; //force new tested to be selected
	else
		ans [i] = correct_queue [fron];
	break;

 case enqueue:
	if (addone(addone(rear))==fron)
		return FALSE; //force new tested to be selected
	else
	       {       argument [i] = int(5*tan(float(rnd(3141))/1000.0));
		       rear = addone(rear);
		       correct_queue [rear] = argument [i];
	       }
	break;

 case dequeue:
	if (addone(rear) == fron)
	       return FALSE; //force new tested to be selected
	else
	       ans [i] = correct_queue [fron];
	       fron = addone(fron);
	break;

 case empty:
	ans [i] = (addone(rear)==fron);
	break;

 default:
	return FALSE; //force new tested to be selected
	break;
}//end case

return TRUE;

}//end set_answer()

int tests_run = 0;
float tests_avg_passed[Max_tests];

int test_total = 0;
int test_cases [empty+1] = {0, 0, 0, 0, 0};
int test_by_length [empty+1][test_queue_limit+2];
int test_Qlength [Max_tests];


float score ( int m, int f, int d, int eq, int em )
{ return m  * makenull_score +
	 f  * ( sign_score + magnitude_score ) +
	 d  * ( sign_score + magnitude_score ) +
         eq * enqueue_score +
         em * empty_score;
}//end score


void	generate_tests()
{
int i = 0;

cout << "Generating test data\n";
memset(tests_avg_passed,0,sizeof(tests_avg_passed));
memset(test_by_length,0,sizeof(test_by_length));


//enum{makenull,front,dequeue,enqueue,empty,adf1,adf2,start_test,end_tests};
const int test_seq_length [Num_test_seq]         =
	                                       { 40,
                                                 40,
                                                 40,
						 40,
						160};
const int probablities [Num_test_seq][(empty+1)] =
	                                       {  1, 20, 34, 25, 20,
                                                 30, 10, 10, 40, 10,
                                                 10, 10, 20, 30, 30,
                                                 10, 40, 20, 20, 10,
                                                  0, 11, 18, 68,  3 };//rescald
#define ptotal 100
#define test_five 4

for (int j = 0; j < Last_test_seq; j++ )
{
test[i++] = start_test;
int old_length = test_queue_limit + 1; //ie not set yet
for (int k=0; k<test_seq_length[j]; k++)
	{
assert ( i < Max_tests );//better than segmention fault
	BOOL try_again;
	do {    try_again = FALSE;
		test[i] = makenull;
		if (k != 0) 
		  {       
			  int r = rnd(ptotal);
			  for ( int m = makenull; m <= empty; m++)
				  if (r < probablities [j][m])
				   {
				     if( (j==test_five)                     &&
                                         (m==enqueue)                       && 
                                         (old_length!=test_queue_limit + 1) && 
                                         (r>=((probablities [j][m] *
                        (test_queue_limit-1-old_length))/(test_queue_limit-1)))
					)
					try_again = TRUE;
				     else 
					test [i] = m;
				     break;
				   }
				  else 
					  r -= probablities [j][m];
		  }

	   } while (try_again==TRUE || set_answer(i)==FALSE);
	test_total++;
	test_cases [test[i]]++;
	test_by_length [test[i]][old_length]++;
	test_Qlength [i] = old_length++;
	old_length = (rear+1+test_queue_limit-fron) % test_queue_limit;
       	i++;
	}//endloop k
}//endloop j
test[i++] = end_tests;

max_fitness = score (
	      test_cases [ makenull ],
	      test_cases [ front ],
	      test_cases [ dequeue ],
              test_cases [ enqueue ],
              test_cases [ empty ]    ) - 
	      1.0/10000.0; //protect against rounding errors

}//end generate_tests()

void write_Qlength(ostream& fout, int k)
{
if ( k <= test_queue_limit ) fout << k << "\t\t";
else                         fout << "undefined\t";
}
      
void write_tests ( ostream& fout = cout )
{
fout<<"\ntest cases\n";
fout << "sign_score\t" << sign_score
<< "  magnitude_score\t" << magnitude_score
<< "  empty_score\t" << empty_score
<< "\nmakenull_score\t" << makenull_score
<< "  dequeue_score as front"
<< "  enqueue_score\t" << enqueue_score
<< "\nmem_penalty\t" << mem_penalty
<< "  per word, if more than " << mem_penalty_bot
<< " words are used" << endl;


int skip = 0;

{for (int i = first_test; test[i] != end_tests; i++)
   {  if ( test [i] == start_test )
	      { skip++;
		if ( skip < first_test_sequence )
			{ for(i++;test[i] < start_test; i++); i--;}
		if ( skip == first_test_sequence )
			{ first_test = i; }
		fout << "\nstart_test\n";
	      }
      else
	     {
	      fout<< i <<"\t";
	      ThisProblem->WriteTreeName(test[i], fout);
	      fout<< "(" << argument[i] << ")  \t" << ans[i];
	      fout<< "\t" << tests_avg_passed[i] << "\t";
	      write_Qlength(fout,test_Qlength[i]); fout<<endl;
             }
   }
}
fout<< "\nRan " << tests_run << " fitness evaluations\n";

{for ( int j = 0; j <= empty; j++ )
	{
	ThisProblem->WriteTreeName(j, fout);
	fout<<" tested " << test_cases [ j ] << " times";
        if ((j == dequeue ) || ( j == empty ))
		fout<<endl;
        else
		fout<<", ";
        }
}

fout << "\nQueue length";
{for ( int j = 0; j <= empty; j++ )
{fout << "\t"; ThisProblem->WriteTreeName(j, fout);}
}
fout << "\tscore" << endl;
{for ( int k = 0; k <= test_queue_limit + 1 ; k++ )
{       write_Qlength(fout,k);
	for ( int j = 0; j <= empty; j++ )
		{ fout << test_by_length [ j ][ k ] << "\t"; }
	fout << score (
	      test_by_length [ makenull ] [ k ],
	      test_by_length [ front    ] [ k ],
	      test_by_length [ dequeue  ] [ k ],
              test_by_length [ enqueue  ] [ k ],
              test_by_length [ empty    ] [ k ]    ) << endl;
}}
fout << endl;

}//end write_tests()


void queue::WriteTreeName(int tree, ostream& ostr)
{switch(tree)
	 {
	 case makenull: ostr<< "makenul"; break;

	 case front:    ostr<< "front"; break;

	 case enqueue:  ostr<< "enqueue"; break;

	 case dequeue:  ostr<< "dequeue"; break;

	 case empty:    ostr<< "empty"; break;

	 case adf1:     ostr<< "adf1"; break;

	 case adf2:     ostr<< "adf2"; break;

	 default:       ostr<< "ERROR322"; break;
	 }
}//end queue::WriteTreeName()

BOOL queue::TreeNameMatch(int tree, char* s)
{switch(tree)
	 {
	 case makenull: return strcmp("makenul", s);
	 case front:    return strcmp("front",   s);
	 case dequeue:  return strcmp("dequeue", s);
	 case enqueue:  return strcmp("enqueue", s);
	 case empty:    return strcmp("empty",   s);
	 case adf1:     return strcmp("adf1",    s);
	 case adf2:     return strcmp("adf2",    s); 
	 default:       return FALSE;
	 }
}//end queue::TreeNameMatch()

BOOL update_score(float& score,
		  int test_done, int actual_answer, int required_ans )
{
//return TRUE => test passed.
switch(test_done)
{
 case makenull:
	score += makenull_score;
	return TRUE;

 case front:
 case dequeue:
	if ( actual_answer == required_ans )
	      { score += magnitude_score;
		return TRUE;
	      }
	else
		return FALSE;
	break;

 case enqueue:
	score += enqueue_score;
	return TRUE;
	break;

 case empty:
	if ( (actual_answer==0) == required_ans )
	      { score += empty_score;
		return TRUE;
	      }
	else
		return FALSE;
	break;

 default:
	assert (0==1);   //catch internal error and terminate gp run
        break;
}//end case
return FALSE;            //not used but keeps compiler happy
}//end update_score()

void display_run (Chrome* chrome, ostream& fout = cout )
// fitness function.
{
int i;
int passed = 0;
float score = 0.0;
memset(store_written,0,sizeof(store_written));
adf1_cache.init();

chrome->SetupEval();

for(i=first_test; test[i] != end_tests; i++)
{
if (test[i] == start_test)
	 {
	 fout<<"\nInitialise everything for new test\n";
	 memory_error = FALSE;
	 recurse_error = FALSE;
	 Aux1 = 0;
	 Aux2 = 0;
	 Aux3 = 0;
	 memset(store,0,sizeof(store));
        }
else
	{retval answer;