Genetic Algorithms Digest    Wednesday, 12 Julyy 1989    Volume 3 : Issue 11

 - Send submissions to GA-List@AIC.NRL.NAVY.MIL
 - Send administrative requests to GA-List-Request@AIC.NRL.NAVY.MIL

Today's Topics:
	- Conference Options for 1990
	- GA/NN papers
	- GA on parity function
	- Computer applications to Biology
	- Bug fix for GENESIS

--------------------------------

Date: Mon, 10 Jul 89 11:18:49 EDT
From: Kenneth Dejong <dejong@aic.nrl.navy.mil>
Subject: Conference Options for 1990

Now that the dust has settled on a very successful ICGA-89, the conference
committee has been evaluating the following options for next year:

	1. Have a full-blown ICGA-90 conference.

	2. Have a less formal workshop next year.

	3. Do nothing at all in 90, but plan for a full-blown ICGA-91.

	4. Take the initiative to make publication opportunities available
	   during 90 in related conferences/journals, and plan for ICGA-91.


Taking into account the feedback received from the community (at the
IGCA-89 business meeting, the IGCA-89 evaluation forms, subsequent
discussions), the committee has agreed on the following:

	1. to not have a full-blown ICGA-90 conference, but to begin
	   planning a West Coast/European ICGA-91.

	2. to leave open the possibility of a less formal workshop
	   next year.  Possible sites: Ann Arbor, Colorado, Santa Fe, 
	   San Diego, AAAI-90.  Host volunteers are solicited.

	3. to agressively create alternative publication opportunities in
	   1990, such as:

	   - GA sessions in the winter and summer Neural Net
             conferences.
	   - GA sessions in the spring ORSA/TIMMS conference.
	   - GA sessions in AAAI-90 and the 1990 Machine Learning conferences.
	   - papers and/or special issues on GAs in journals: 
	     Machine Learning, IEEE SMC, Complex Systems, Cognitive Science,
	     etc.

These decisions were not made easily, but I believe they represent a
realistic composite of a wide variety of opinions and options.  However,
without your support, these plans will not be successful.  We need
proposals for ICGA-91, a possible workshop in 90, initiators of
conference sessions on GAs, etc.

Let's also agree to use GA-LIST more effectively in communicating 
opportunities and ideas.

Have a good summer!

	Ken De Jong, ICGA-89 Conference Chair

--------------------------------

Date: Mon, 10 Jul 89 20:57:54 EDT
From: mlittman@wind.bellcore.com (Michael S. Littman)
Subject: GA/NN papers

You posted a note explaining the existence of a session in INNS
concerning evolution and neural nets.  You said the conference would be
in January and you gave details for submission but you didn't give a
deadline date.

I have been collaborating on an interesting GA/NN link that I think
would be highly appropriate for such a session but I don't know if I'd
be able to get an abstract together in time.  Do you know when the
deadline is or who I could ask?  Thanks for your time and helpfulness!

-Michael

[ Papers must be postmarked by 1 August 89, and received by 10 August 89.
- JJG ]

--------------------------------

Date: Fri, 7 Jul 89 14:28:15 EDT
From: jima@starbase.mitre.org (Jim Antonisse)
Subject: GA on parity function

I was just given a problem (by George Benke, a methemetician here who's
trying to understand the GA) that it seems the ga is absolutely no good
for, as far as we can tell.

The problem is to model an environment defined by the parity function,
where a string has value 1 if it has an even number of bits, and 0
otherwise.  The function is very global in character.  It seems to so
completely violate the building blocks assumption that (correct me if
I'm wrong) the ga drives to a population with 50% even, 50% odd parity
even if it starts with a "really good" population of 100% even parity
individuals.  This is because the odds of crossover between good parents
leading to good offspring is 50%.  Mutation would seem to be even worse.

Someone out there must have looked at this before.  Is there a way in
which a solution to this problem might conceivably evolve?  How?

Jim Antonisse
MITRE

--------------------------------

Date: Tue, 4 Jul 89 10:36:58 +0200
From: meyer@FRULM63.BITNET (Jean-Arcady MEYER)
Subject: Computer applications to Biology

I belong to a group working on computer applications to Biology, which
depends of the PARIS_6 University and French CNRS.

At a theoretical level, we are interested in the interactions of
learning, development and evolution in adaptive systems.

We also apply genetic algorithms and classifier systems for solving
technical biological problems, like opimizing the best match between two
2D-electrophoresis images or learning to discriminate introns from exons
in DNA sequences.

Please register my name on your GA-list:

Dr. J.A. MEYER
URA686. Groupe de BioInformatique
Ecole Normale Superieure
46 rue d'Ulm
75230 PARIS. Cedex 05.
FRANCE
e-mail : meyer@frulm63.bitnet

Thank you

--------------------------------

Date: Tue, 11 Jul 89 14:58:49 EDT
From: John Grefenstette <gref@aic.nrl.navy.mil>
Subject: Bug fix for GENESIS

Jon Richardson notified me about a bug in the GENESIS crossover
operator.  Jon's note outlines the problem.  My replacement for
cross.c follows.

- John

----

Date: Tue, 11 Jul 89 00:28:59 EDT
From: Jon Richardson <richards%ALPHARD.CS.UTK.EDU@utkcs2.cs.utk.edu>
To: gref@aic.nrl.navy.mil
Subject: Genesis Problem.

John,

   While  porting  Genesis to my new PC/AT clone,  I ran  into  a 
problem  which  I  find  particularly  disturbing:  Crossover  is 
correct  as long as the crossover points are in separate bytes of 
the packed gene.   However,  if the two crossover points fall  in 
the  same  byte,  the wrong loci are  crossed.  

   The crossover algorithm can be summarized thus:

       (1) Do 1-pt crossover on xbyte1 (swapping portions to the
                                              right of xbit1).  
       (2) swap complete bytes between xbyte1 and xbyte2.
       (3) Do 1-pt crossover on xbyte2. (swapping portions to the
                                              left of xbit2).

   When  xbyte1=xbyte2(=xbyte) xbyte is broken into three pieces.  
The middle section is swapped twice (both in step 1 and step  2).  
The  end  sections  are swapped once.   The effect then  is  that 
instead  of  the  string portion between xbit1  and  xbit2  being 
swapped,  there  is an exchanging of bits between the two  xbit's 
and  the  byte boundaries.   No change occurs between  xbit1  and 
xbit2.   This  can be viewed as a four-point crossover  with  the 
additional two points thrown in at the byte boundaries.
   
   This behavior was observed on my PC using TurboC v1.5.  I have 
not  had  the  opportunity  to look for  it  on  a  Unix-speaking 
machine, but I am sure It will occur there as well. 

   I hope to hear from you soon.   If there is anything I can do, 
please let me know.

             Sincerely,
                  Jon Richardson.
                  141-C Angela Dr
                  Madison, AL 35758.
                  205-837-9043.
                  richards@utkcs2.cs.utk.edu  

----
----

Here's the fixed code:
- JJG

----------------------  cut here ------------------------------
/*************************************************************/
/*                                                           */
/*  Copyright (c) 1986                                       */
/*  John J. Grefenstette                                     */
/*  Navy Center for Applied Research in AI                   */
/*  Naval Research Laboratory                                */
/*                                                           */
/*  Permission is hereby granted to copy all or any part of  */
/*  this program for free distribution.   The author's name  */
/*  and this copyright notice must be included in any copy.  */
/*                                                           */
/*************************************************************/

/*
 *  file:	cross.c
 *
 *  author:	John J. Grefenstette
 *
 *  created:	1981
 *
 *  purpose:	perform two-point crossover on entire population
 *
 *  modified:	8 apr 86
 *
 *		13 nov 86:  perform crossover on packed structures.
 *
 *              4 august 87: add second crossover point
 *
 *              11 july 89: fix bug when xbyte1 == xbyte2 
 *                   (bug found by Jon Richardson.)
 */

#include "extern.h"

char premask[CHARSIZE] = { '\000', '\200', '\300', '\340',
				'\360', '\370', '\374', '\376' };

char postmask[CHARSIZE] = { '\377', '\177', '\077', '\037',
				'\017', '\007', '\003', '\001'};


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");

	if (firstflag)
	  {
	    last = (C_rate*Popsize) - 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; i < Bytes; i++) diff += (kid1[i] != kid2[i]);

		if (diff)	/* they do */
		{


 		  /* Debugging code */
		  /*
		     if (xbyte1 == xbyte2) {
		       printf("\nbyte: %d  bit1: %d  bit2: %d\n",
			      xbyte1,xbit1, xbit2);
		       Unpack ( New[mom].Gene, Buff, Length);
		       for (i=0; i<Length; i++) {
			 printf("%1d", Buff[i]);
			 if ((i+1) % 8 == 0) printf(" ");
		       }
		       printf("\n");
		       Unpack ( New[dad].Gene, Buff, Length);
		       for (i=0; i<Length; i++) {
			 printf("%1d", Buff[i]);
			 if ((i+1) % 8 == 0) printf(" ");
		       }
		       printf("\n");
		     }
		     */

			/* 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]) );

				/* Debugging code */
				/*
				printf("\n");
				if (diff) {
				  Unpack ( New[mom].Gene, Buff, Length);
				  for (i=0; i<Length; i++) {
				    printf("%1d", Buff[i]);
				    if ((i+1) % 8 == 0) printf(" ");
				  }
				  printf("\n");
				  Unpack ( New[dad].Gene, Buff, Length);
				  for (i=0; i<Length; i++) {
				    printf("%1d", Buff[i]);
				    if ((i+1) % 8 == 0) printf(" ");
				  }
				  printf("\n");
				}
				else
				  printf("no diff\n");
				*/
			}

			if (diff)	/* kids differ from parents */
			{
				/* set evaluation flags */
				New[mom].Needs_evaluation = 1;
				New[dad].Needs_evaluation = 1;
			}
		}
	}
	Trace("Crossover completed");
}

/** end of file **/


--------------------------------

End of Genetic Algorithms Digest
********************************

