int Idump (int argc, lvar_t *argv) {
int i;
if (argc == 0)
Dtrace (root, 0);
else
for (i = 0; i < argc; i++)
Dtrace (argv[i].o, 0);
return L_SUCCESS;
}
Evaluate()
{
register double performance;
register int i;
register how_many; /* # of models to evaluate */
int idebug; /* DEBUG */
Trace("Evaluate entered");
Dtrace("evaluate");
for (how_many=0, i=0; i<Popsize; i++)
{
if ( New[i].Needs_evaluation )
{
Unpack(New[i].Gene, Bitstring, Length);
if (Floatflag)
{
FloatRep(Bitstring, to_be_calculated[how_many], Genes);
how_many++;
}
}
}
eval(how_many, Genes);
for (how_many=0, i=0; i < Popsize; i++)
{
if ( New[i].Needs_evaluation )
{
New[i].Perf = eval_returned[how_many];
how_many++;
performance = New[i].Perf;
New[i].Needs_evaluation = 0;
Trials++;
TrialTotal++;
Spin = 0; /* we're making progress */
if (Savesize) Savebest(i);
if (Trials == 1)
Best = performance;
if (BETTER(performance, Best))
{
Best = performance;
}
Onsum += performance;
Offsum += Best;
}
}
Trace("Evaluate completed");
}
int Iecho (int argc, lvar_t *argv) {
int i;
for (i = 0; i < argc; i++) {
switch (Tgettype (argv[i].o)) {
case T_STRING: printf ("%s", Tgetstring (argv[i].o)); break;
case T_INTEGER: printf ("%ld", Tgetinteger (argv[i].o)); break;
case T_REAL: printf ("%f", Tgetreal (argv[i].o)); break;
case T_TABLE: printf ("[\n"), Dtrace (argv[i].o, 4); break;
}
}
printf ("\n");
return L_SUCCESS;
}
Mutate()
{
static int bits; /* number of bits per pop */
register int i; /* index of the Mutated structure */
register int j; /* position within the structure */
register char k; /* a random allele */
register int open; /* currently Unpacked Gene */
static int firstflag = 1;
Trace("Mutate entered");
Dtrace("mutation");
if (firstflag)
{
bits = Gapsize*Popsize*Length + 0.5;
firstflag = 0;
}
if (M_rate > 0.0)
{
open = -1;
while (Mu_next<bits)
{
i = Mu_next/ Length; /* Mutated structure */
j = Mu_next % Length; /* Mutated position */
if (open != i) /* need to Unpack structure i */
{
Unpack (New[i].Gene , Bitstring, Length);
open = i;
}
/* choose a random allele */
if (Randint(0,1))
k = '1';
else
k = '0';
if (k != Bitstring[j]) /* it's an effective mutation */
{
Bitstring[j] = k;
New[i].Needs_evaluation = 1;
}
if (New[i].Needs_evaluation)
Pack ( Bitstring , New[i].Gene , Length);
/* update next mutation location */
if (M_rate < 1.0)
Mu_next += ceil (log(Rand()) / log(1.0 - M_rate));
else
Mu_next += 1;
}
/* adjust Mu_next for next Generation */
Mu_next -= bits;
}
Trace("Mutate completed");
}
Crossover()
{
register int mom, dad; /* participants in the crossover */
register int xpoint1; /* first crossover point w.r.t. structure */
register int xpoint2; /* second crossover point w.r.t. structure */
register int xbyte1; /* first crossed byte */
register int xbit1; /* first crossed bit in xbyte1 */
register int xbyte2; /* last crossed byte */
register int xbit2; /* last crossed bit in xbyte2 */
register int i; /* loop control variable */
register char temp; /* used for swapping alleles */
static int last; /* last element to undergo Crossover */
int diff; /* set if parents differ from offspring */
char *kid1; /* pointers to the offspring */
char *kid2;
static int firstflag = 1;
Trace("Crossover entered");
Dtrace("crossover");
if (firstflag)
{
last = (C_rate*Popsize*Gapsize) - 0.5 ;
firstflag = 0;
}
for (mom=0; mom < last ; mom += 2)
{
dad = mom + 1;
/* kids start as identical copies of parents */
kid1 = New[mom].Gene;
kid2 = New[dad].Gene;
/* choose two Crossover points */
xpoint1 = Randint(0,Length);
xpoint2 = Randint(0,Length-1);
/* guarantee that xpoint1 < xpoint2 */
if (xpoint2 >= xpoint1)
xpoint2++;
else
{
i = xpoint1;
xpoint1 = xpoint2;
xpoint2 = i;
}
xbyte1 = xpoint1 / CHARSIZE;
xbit1 = xpoint1 % CHARSIZE;
xbyte2 = xpoint2 / CHARSIZE;
xbit2 = xpoint2 % CHARSIZE;
/* do parents differ outside cross segment? */
diff = 0;
for (i=0; i < xbyte1; i++) diff += (kid1[i] != kid2[i]);
diff += ( (kid1[xbyte1] & premask[xbit1]) !=
(kid2[xbyte1] & premask[xbit1]) );
diff += ( (kid1[xbyte2] & postmask[xbit2]) !=
(kid2[xbyte2] & postmask[xbit2]) );
for (i=xbyte2+1; i < Bytes; i++) diff += (kid1[i] != kid2[i]);
if (diff) /* they do */
{
/* perform crossover */
temp = kid1[xbyte1];
kid1[xbyte1] = (kid1[xbyte1] & premask[xbit1]) |
(kid2[xbyte1] & postmask[xbit1]);
kid2[xbyte1] = (kid2[xbyte1] & premask[xbit1]) |
(temp & postmask[xbit1]);
diff = ((kid1[xbyte1] & postmask[xbit1]) !=
(kid2[xbyte1] & postmask[xbit1]) );
for (i=xbyte1 + 1; i < xbyte2; i++)
{
temp = kid1[i];
kid1[i] = kid2[i];
kid2[i] = temp;
diff += (kid1[i] != kid2[i]);
}
if (xbyte1 < xbyte2)
{
temp = kid1[xbyte2];
kid1[xbyte2] = (kid1[xbyte2] & postmask[xbit2]) |
(kid2[xbyte2] & premask[xbit2]);
kid2[xbyte2] = (kid2[xbyte2] & postmask[xbit2]) |
(temp & premask[xbit2]);
diff += ((kid1[xbyte2] & premask[xbit2]) !=
(kid2[xbyte2] & premask[xbit2]) );
}
else
{
temp = kid1[xbyte2];
kid1[xbyte2] = (kid1[xbyte2] & premask[xbit2]) |
(kid2[xbyte2] & postmask[xbit2]);
kid2[xbyte2] = (kid2[xbyte2] & premask[xbit2]) |
(temp & postmask[xbit2]);
diff = ((kid1[xbyte2] & postmask[xbit1] & premask[xbit2]) !=
(kid2[xbyte2] & postmask[xbit1] & premask[xbit2]) );
}
if (diff) /* kids differ from parents */
{
/* set evaluation flags */
New[mom].Needs_evaluation = 1;
New[dad].Needs_evaluation = 1;
}
}
}
Trace("Crossover completed");
}
