Newsgroups: comp.ai.genetic,comp.answers,news.answers
Path: cantaloupe.srv.cs.cmu.edu!das-news2.harvard.edu!cam-news-feed3.bbnplanet.com!news.bbnplanet.com!cam-news-hub1.bbnplanet.com!howland.erols.net!news-peer.gsl.net!news.gsl.net!news-lond.gsl.net!news.gsl.net!netcom.net.uk!nuntius.u-net.net!yama.mcc.ac.uk!loki.cf.ac.uk!scmdb
From: David.Beasley@cs.cf.ac.uk (David Beasley)
Subject: FAQ: comp.ai.genetic part 5/6 (A Guide to Frequently Asked Questions)
Summary: This is part 5 of a <trilogy> entitled "The Hitch-Hiker's Guide
     to Evolutionary Computation". A periodically published list of Frequently
     Asked Questions (and their answers) about Evolutionary Algorithms,
     Life and Everything. It should be read by anyone who whishes to post
     to the comp.ai.genetic newsgroup, preferably *before* posting.
Originator: scmdb@thrall.cs.cf.ac.uk
Sender: news@cf.ac.uk (Usenet News user)
Message-ID: <part5_850729073@cs.cf.ac.uk>
Supersedes: <part5_843226984@cs.cf.ac.uk>
Approved: news-answers-request@MIT.Edu
Date: Mon, 16 Dec 1996 09:38:10 GMT
Expires: Thu, 20 Mar 1997 09:37:53 GMT
X-Nntp-Posting-Host: thrall.cs.cf.ac.uk
References: <part4_850729073@cs.cf.ac.uk>
Organization: Posted through the Joint Cardiff Computing Service, Wales, UK
Followup-To: comp.ai.genetic
Lines: 1728
Xref: glinda.oz.cs.cmu.edu comp.ai.genetic:10633 comp.answers:23104 news.answers:1785

Archive-name:   ai-faq/genetic/part5
Last-Modified:  12/20/96
Issue:          4.4

TABLE OF CONTENTS OF PART 5
     Q20: What EA software packages are available?
     Q20.1: Free software packages?
     Q20.2: Commercial software packages?
     Q20.3: Current research projects?

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

Subject: Q20: What EA software packages are available?

     This  gives a list of all known EA software packages available to the
     public. The list was originally maintained by Nici  Schraudolph.   In
     June  '93  it  was agreed that it would be incorporated into this FAQ
     and the responsibility for maintenance taken over by the FAQ  editor.

     A  copy  of  most of the packages described below are kept at ENCORE,
     (See Q15.3), available by anonymous FTP.

     Most  GENETIC  PROGRAMMING  software  is   available   by   FTP   in:
     ftp.io.com:/pub/genetic-programming/    There    are   subdirectories
     containing papers related to GP, archives of  the  mailing  list,  as
     well  as  a  suite  of  programs for implementing GP.  These programs
     include the Lisp code from Koza's "Genetic Programming" [KOZA92],  as
     well  as  implementations  in  C and C++, as for example SGPC: Simple
     Genetic Programming in C by Walter Alden  Tackett  and  Aviram  Carmi
     <gpc@ipld01.hac.com>.

     A  survey paper entitled "Genetic Algorithm Programming Environments"
     was published in IEEE Computer in the February 1994  issue.   Written
     by  Filho,  Alippi  and  Treleaven of University College, London, UK.
     It's            available            by            FTP             as
     bells.cs.ucl.ac.uk:/papagena/game/docs/gasurvey.ps

 PLEASE NOTE
     For  many  of these software packages, specific ordering instructions
     are given in the  descriptions  below  (see  Q20.1  -  Free  Software
     packages,  Q20.2  -  Commercial  Software  Packages, Q20.3 - Research
     Projects).   Please  read  and  follow  them   before   unnecessarily
     bothering  the  listed  author  or  contact!   Also  note  that these
     programs  haven't  been  independently  tested,  so  there   are   no
     guarantees of their quality.

     A major revision was undertaken in August 1994, when all authors were
     contacted, and asked to  confirm  the  accuracy  of  the  information
     contained  here.  A  few  authors  did not respond to the request for
     information.  These are noted below by: (Unverified 8/94).  In  these
     cases,  FTP  address  were checked by the FAQ editor, to confirm that
     this information (at least) is correct. In two cases,  email  to  the
     author bounced back as "undeliverable" -- these are noted below.

 Legend
     Type (this is a very ad-hoc classification)

	       GE:  generational GA
	       SS:  steady-state GA
	       PA:  (pseudo) parallel GA
	       ES:  evolution strategy
	       OO:  object-oriented
	       XP:  expert system
	       ED:  educational/demo
	       CF:  classifier system

     OS   Operating  System;  X11  implies  Unix;  "Win"  means  Microsoft
	  Windows 3.x/NT (PC); "DOS" means MS-DOS or compatibles.

     Lang Programming Language; in parentheses: source code not  included;
	  "OPas" = MPW Object Pascal

     Price
	  (1)   free   to  government  contractors,  $221  otherwise,  (2)
	  educational discount available, (3) available as addendum  to  a
	  book,  (4)  single 1850 DM, site license 5200 DM, (5) single 200
	  DM, site license 500 DM, (6) free for academic  and  educational
	  use.

     Author or Contact
	  given as Internet e-mail address if possible
		   ES/GA/XP System Implementations:

     =========================================================================
      Name       Type OS       Lang  Price  Author/Contact
     =========================================================================

      BUGS        GE, X11,    C      free   Joshua Smith
		  ED  Suntools             <jrs@media.mit.edu>

      Computer-   ED, Win     ?      free   Scott Kennedy, Axcelis Inc.
      Ants        GA                       <staff@axcelis.com>

      DGenesis    GE, Unix    C      free   Erick Cantu-Paz
		 PA,ED                     <ecantu@lamport.rhon.itam.mx>

      DOUGAL      SS, DOS     Turbo  free   Brett Parker
		  GE          Pascal       <b.s.parker@durham.ac.uk>

      ESCaPaDE    ES  Unix    C      free   Frank Hoffmeister
				<hoffmeister@ls11.informatik.uni-dortmund.de>

      Evolution   GE, DOS     C      free   Hans-Michael Voigt and
      Machine     ES                        Joachim Born
					   <voigt@max.fb10.tu-berlin.de>

      GAC,        GE  Unix    C      free   Bill Spears
      GAL         "   "       Lisp   "     <spears@aic.nrl.navy.mil>

      GAGA        GE  Unix    C      free   Jon Crowcroft
					   <jon@cs.ucl.ac.uk>

      GAGS        GE, Unix,   C++    free   JJ Merelo
	       SS,OO  DOS                  <jmerelo@kal-el.ugr.es>

      GAlib       GA  Unix,   C++    free   Matthew Wall
		      Mac,DOS              <mbwall@mit.edu>

      GALOPPS     GE, Unix,   C      free   Erik Goodman
		  PA  DOS                  <goodman@egr.msu.edu>

      GAMusic     ED  Win    (VB)    $10   Jason H. Moore
					   <jhm@superh.hg.med.umich.edu>

      GANNET      GE, Unix    C      free   Darrell Duane
		  NN                       <dduane@fame.gmu.edu>

      GAucsd      GE  Unix    C      free   Nici Schraudolph
					   <GAucsd-request@cs.ucsd.edu>

      GA          GE, DOS     (C++)  free   Mark Hughes
      Workbench   ED                       <mrh@i2ltd.demon.co.uk>

      GECO        GE, Unix,   Lisp   free   George P. W. Williams, Jr.
		OO,ED MacOS                <george@hsvaic.hv.boeing.com>

      Genesis     GE, Unix,   C      free   John Grefenstette
		  ED  DOS                  <gref@aic.nrl.navy.mil>

      GENEsYs     GE  Unix    C      free   Thomas Baeck
				      <baeck@ls11.informatik.uni-dortmund.de>

      GenET       SS, Unix,   C      free   Cezary Z. Janikow
		ES,ED X, etc.              <janikow@radom.umsl.edu>

      Genie       GE  Mac     Think  free   Lance Chambers
			      Pascal       <pstamp@yarrow.wt.uwa.edu.au>

      Genitor     SS  Unix    C      free   Darrell Whitley
					   <whitley@cs.colostate.edu>

      GENlib      SS  Unix,   C      (6)    Jochen Ruhland
		      DOS            <jochenr@neuro.informatik.uni-kassel.de>

      GENOCOP     GE  Unix    C      free   Zbigniew Michalewicz
					   <zbyszek@uncc.edu>

      GIGA        SS  Unix    C      free   Joe Culberson
					   <joe@cs.ualberta.ca>

      GPEIST      GP  Win,   Small-  free   Tony White
		      OS/2   talk          <arpw@bnr.ca>

      Imogene     GP  Win     C++    free   Harley Davis
					   <davis@ilog.fr>

      JAG         GA  -      Java   free   Stephen Hartley
					   <shartley@mcs.drexel.edu>

      LibGA       GE, Unix/DOS C     free   Art Corcoran
	       SS,ED  NeXT/Amiga           <corcoran@penguin.mcs.utulsa.edu>

      LICE        ES  Unix,   C      free   Joachim Sprave
		      DOS                  <joe@ls11.informatik.uni-dortmund.de>

      Matlab-GA   GE  ?       Matlab free   Andy Potvin
					   <potvin@mathworks.com>

      mGA         GE  Unix    C,     free   Dave Goldberg
			      Lisp         <goldberg@vmd.cso.uiuc.edu>

      PARAGenesis PA, CM      C*     free   Michael van Lent
		  GE                       <vanlent@eecs.umich.edu>

      PGA         PA, Unix,   C      free   Peter Ross
		SS,GE etc.                 <peter@aisb.ed.ac.uk>

      PGAPack     GA, any     C      free   David Levine
		  PA                       <levine@mcs.anl.gov>

      REGAL       GA          C      free   Filippo Neri
					   <neri@di.unito.it>

      SGA-C,      GE  Unix    C      free   Robert E. Smith
      SGA-Cube        nCube                <rob@comec4.mh.ua.edu>

      Splicer     GE  Mac,    C      (1)    Steve Bayer
		      X11

      TOLKIEN     OO, Unix,   C++    free   Anthony Yiu-Cheung Tang
		  GE  DOS                  <tang028@cs.cuhk.hk>

      Trans-Dimensional                     Steve Romaniuk
      Learning    NN  Win     ?      free  <zlxx69a@prodigy.com>

      WOLF        SS  Unix    C      free   David Rogers
					   <drogers@msi.com>
     =========================================================================

		  Classifier System Implementations:

     =========================================================================
      Name     Type  OS      Lang   Price  Author/Contact
     =========================================================================

      CFS-C     CF,  Unix/DOS  C    free   Rick Riolo
		ED                        <rlr@merit.edu>

      SCS-C     CF,  Unix/DOS  C    free   Joerg Heitkoetter
		ED   Atari TOS            <joke@Germany.EU.net>
     ==========================================================================

		     Commercial Packages:

     =========================================================================
      Name     Type  OS      Lang   Price  Author/Contact
     =========================================================================

      EnGENEer  OO,  X11      C       ?     George Robbins,
		GA                          Logica Cambridge Ltd.

      EvoFrame/ OO,  Mac,     C++/   (4,2)  Optimum Software
      REALizer  ES   DOS      OPas   (5,2) <optimum@applelink.apple.com>

      Evolver   GE   DOS,     (C,    $349   Palisade Corp
		     Mac      Pascal)

      FlexTool  GA   Win      Matlab ?      Flexible Intelligence Group
					   <info@flextool.com>

      GAME      OO,  X11      C++     (3)   Jose R. Filho
		GA                         <zeluiz@cs.ucl.ac.uk>

      GeneHunter GA  Win,    (VB)    $369   Ward Systems
		     Excel                 <wardsystems@msn.com>

      Generator GE,SS Win,   (C++)   $379   Steve McGrew, New Light Industries
	     ES,OO,ED Excel                <nli@comtch.iea.com>

      MicroGA/  OO,  Mac,     C++    $249   Emergent Behavior, Inc.
      Galapagos SS   Win              (2)  <emergent@aol.com>

      Omega     ?    DOS      ?       ?     David Barrow, KiQ Ltd.

      OOGA      OO,  Mac,     Lisp   $60    Lawrence Davis
		GE   DOS

      PC/Beagle XP   DOS      ?      69UKP  Richard Forsyth

      XpertRule/XP   DOS    (Think  995UKP  Attar Software
      GenAsys                Pascal)       <100116.1547@compuserve.com>

      XYpe      SS   Mac     (C)     $725   Ed Swartz, Virtual Image Inc.
     =========================================================================
------------------------------

Subject: Q20.1: Free software packages?

 BUGS:
     BUGS  (Better  to  Use Genetic Systems) is an interactive program for
     demonstrating the GENETIC ALGORITHM and is written in the  spirit  of
     Richard  Dawkins'  celebrated Blind Watchmaker software. The user can
     play god (or `GA FITNESS  function,'  more  accurately)  and  try  to
     evolve  lifelike organisms (curves). Playing with BUGS is an easy way
     to get an understanding of how and why the GA works. In  addition  to
     demonstrating  the basic GENETIC OPERATORs (SELECTION, CROSSOVER, and
     MUTATION), it allows users to easily  see  and  understand  phenomena
     such as GENETIC DRIFT and premature convergence. BUGS is written in C
     and runs under Suntools and X Windows.

     BUGS was written by  Joshua  Smith  <jrs@media.mit.edu>  at  Williams
     College       and       is       available      by      FTP      from
     santafe.edu:/pub/misc/BUGS/BUGS.tar.Z            and             from
     ftp.aic.nrl.navy.mil:/pub/galist/src/ga/BUGS.tar.Z  Note  that  it is
     unsupported software, copyrighted but freely distributable.  Address:
     Room  E15-492,  MIT  Media  Lab, 20 Ames Street, Cambridge, MA 02139.
     (Unverified 8/94).

 ComputerAnts:
     ComputerAnts is a free Windows program  that  teaches  principles  of
     GENETIC  ALGORITHMs  by  breeding  a  colony of ants on your computer
     screen. Users create  ants,  food,  poison,  and  set  CROSSOVER  and
     MUTATION  rates.  Then they watch the colony slowly evolve.  Includes
     extensive on-line help  and  tutorials  on  genetic  algorithms.  For
     further information or to download, see http://www.axcelis.com

 DGenesis:
     DGenesis  is  a  distributed  implementation of a Parallel GA.  It is
     based on Genesis 5.0. It runs on a network of UNIX workstations.   It
     has  been  tested  with DECstations, microVAXes, Sun Workstations and
     PCs running 386BSD 0.1. Each  subpopulation  is  handled  by  a  UNIX
     process  and  the  communication  between  them is accomplished using
     Berkeley sockets. The system is programmed in C and is available free
     of  charge  by  anonymous  FTP  from  lamport.rhon.itam.mx:/ and from
     ftp.aic.nrl.navy.mil:/pub/galist/src/ga/dgenesis-1.0.tar.Z

     DGenesis allows the user to set the MIGRATION interval, the migration
     rate  and  the  topology  between the SUB-POPULATIONs.  There has not
     been much work investigating  the  effect  of  the  topology  on  the
     PERFORMANCE of the GA, DGenesis was written specifically to encourage
     experimentation in this area. It still needs  many  refinements,  but
     some may find it useful.

     Contact   Erick   Cantu-Paz   <ecantu@lamport.rhon.itam.mx>   at  the
     Instituto Tecnologico Autonomo de Mexico (ITAM)

 Dougal:
     DOUGAL is a demonstration program for solving the TRAVELLING SALESMAN
     PROBLEM  using  GAs.   The  system  guides  the  user through the GA,
     allowing them to see the results of altering parameters  relating  to
     CROSSOVER,  MUTATION  etc.   The  system  demonstrates graphicaly the
     OPTIMIZATION  of  the  route.   The  options  open  to  the  user  to
     experiment with include percentage CROSSOVER and MUTATION, POPULATION
     size, steady state or  generational  replacement,  FITNESS  technique
     (linear normalised, is evaluation, etc).

     DOUGAL  requires  an  IBM  compatible  PC  with  a  VGA monitor.  The
     software is free, however I would appreciate  feedback  on  what  you
     think of the software.

     Dougal   is  available  by  FTP  from  ENCORE  (see  Q15.3)  in  file
     EC/GA/src/dougal.zip  It's  pkzipped  and  contains  executable,  vga
     driver, source code and full documentation.  It is important to place
     the vga driver (egavga.bgi) in the same directory as DOUGAL.  Author:
     Brett  Parker,  7  Glencourse,  East  Boldon,  Tyne + Wear, NE36 0LW,
     England. <b.s.parker@durham.ac.uk>

 ESCaPaDE:
     ESCaPaDE is a sophisticated software environment to  run  experiments
     with  Evolutionary  Algorithms,  such  as e.g. an EVOLUTION STRATEGY.
     The main support for experimental work is provided  by  two  internal
     tables:  (1)  a  table  of objective functions and (2) a table of so-
     called data monitors, which allow easy  implementation  of  functions
     for  monitoring  all  types  of  information  inside the Evolutionary
     Algorithm under experiment.

     ESCaPaDE 1.2 comes with the  KORR  implementation  of  the  evolution
     strategy  by  H.-P.  Schwefel  which  offers  simple  and  correlated
     MUTATIONs.  KORR is provided as a  FORTRAN  77  subroutine,  and  its
     cross-compiled C version is used internally by ESCaPaDE.

     An   extended   version   of   the   package  was  used  for  several
     investigations so far  and  has  proven  to  be  very  reliable.  The
     software  and  its documentation is fully copyrighted although it may
     be freely used for scientific work; it requires 5-6 MB of disk space.

     In  order  to  obtain  ESCaPaDE,  please send a message to the e-mail
     address below.  The  SUBJECT  line  should  contain  'help'  or  'get
     ESCaPaDE'.   (If  the  subject  lines  is  invalid, your mail will be
     ignored!).  For more information contact: Frank Hoffmeister,  Systems
     Analysis  Research  Group,  LSXI,  Department  of  Computer  Science,
     University   of   Dortmund,   D-44221   Dortmund,   Germany.     Net:
     <hoffmeister@ls11.informatik.uni-dortmund.de>

 Evolution Machine:
     The  Evolution  Machine  (EM) is universally applicable to continuous
     (real-coded)  OPTIMIZATION  problems.  In  the  EM  we   have   coded
     fundamental    evolutionary   algorithms   (GENETIC   ALGORITHMs  and
     EVOLUTION  STRATEGIEs),  and  added  some  of   our   approaches   to
     evolutionary search.

     The EM includes extensive menu techniques with:

     o  Default parameter setting for unexperienced users.

     o  Well-defined  entries  for   EM-control  by freaks of the EM,  who
	want  to leave  the standard  process control.

     o  Data processing for repeated runs (with or without change  of  the
	strategy parameters).

     o  Graphical  presentation  of  results:   online presentation of the
	EVOLUTION  progress,  one-,  two-  and  three-dimensional  graphic
	output  to analyse the FITNESS function and the evolution process.

     o  Integration of calling MS-DOS utilities (Turbo C).

     We provide  the EM-software in object code,  which can be run on PC's
     with MS-DOS and Turbo C, v2.0,  resp. Turbo C++,v1.01.  The Manual to
     the EM is included in the distribution kit.

     The  EM  software  is  available  by  FTP  from   ftp-bionik.fb10.tu-
     berlin.de:/pub/software/Evolution-Machine/  This  directory  contains
     the compressed files em_tc.exe (Turbo C), em_tcp.exe (Turbo C++)  and
     em_man.exe  (the  manual).  There  is  also em-man.ps.Z, a compressed
     PostScript file of the manual.  If you do not have FTP access, please
     send us either 5 1/4 or 3 1/2 MS-DOS compatible disks. We will return
     them with the compressed files (834 kB).

     Official contact information: Hans-Michael  Voigt  or  Joachim  Born,
     Technical   University   Berlin,  Bionics  and  evolution  Techniques
     Laboratory, Bio- and Neuroinformatics  Research  Group,  Ackerstrasse
     71-76   (ACK1),    D-13355  Berlin,  Germany.   Net:  <voigt@fb10.tu-
     berlin.de>, <born@fb10.tu-berlin.de> (Unverified 8/94).

 GA Workbench:
     A mouse-driven interactive GA demonstration program aimed  at  people
     wishing to show GAs in action on simple FUNCTION OPTIMIZATIONs and to
     help  newcomers  understand  how  GAs  operate.   Features:   problem
     functions   drawn  on  screen  using  mouse,  run-time  plots  of  GA
     POPULATION distribution, peak and average FITNESS.  Useful population
     STATISTICS  displayed numerically, GA configuration (population size,
     GENERATION   gap   etc.)   performed   interactively   with    mouse.
     Requirements: MS-DOS PC, mouse, EGA/VGA display.

     Available  by  FTP  from  the  simtel20  archive mirrors, e.g.  wsmr-
     simtel20.army.mil:/pub/msdos/neurlnet/gaw110.zip                   or
     wuarchive.wustl.edu:  or  oak.oakland.edu:  Produced  by  Mark Hughes
     <mrh@i2ltd.demon.co.uk>. A windows version is in preparation.

 GAC, GAL:
     Bill Spears <spears@aic.nrl.navy.mil> writes: These are packages I've
     been  using  for  a  few  years.  GAC is a GA written in C. GAL is my
     Common  Lisp  version.  They  are   similar   in   spirit   to   John
     Grefenstette's  Genesis,  but  they don't have all the nice bells and
     whistles. Both versions currently run on  Sun  workstations.  If  you
     have something else, you might need to do a little modification.

     Both  versions  are  free: All I ask is that I be credited when it is
     appropriate. Also, I would  appreciate  hearing  about  improvements!
     This software is the property of the US Department of the Navy.

     The  code  will  be  in a "shar" format that will be easy to install.
     This  code  is  "as  is",  however.  There  is  a  README  and   some
     documentation in the code. There is NO user's guide, though (nor am I
     planning on writing one at this time). I  am  interested  in  hearing
     about  bugs,  but  I  may  not get around to fixing them for a while.
     Also, I will be unable to answer many questions about  the  code,  or
     about  GAs in general. This is not due to a lack of interest, but due
     to a lack of free time!

     Available                 by                 FTP                 from
     ftp.aic.nrl.navy.mil:/pub/galist/src/ga/GAC.shar.Z  and  GAL.shar.Z .
     PostScript versions of some papers  are  under  "/pub/spears".   Feel
     free to browse.

 GAGA:
     GAGA  (GA  for  General  Application) is a self-contained, re-entrant
     procedure which is suitable for the minimization of many  "difficult"
     cost  functions.   Originally  written in Pascal by Ian Poole, it was
     rewritten in C by Jon Crowcroft. GAGA can be obtained by request from
     the  author:  Jon  Crowcroft  <jon@cs.ucl.ac.uk>,  Univeristy College
     London,  Gower  Street,  London  WCIE  6BT,  UK,  or  by   FTP   from
     ftp://cs.ucl.ac.uk:/darpa/gaga.shar

 GAGS:
     GAGS  0.92  (Genetic Algorithms from Granada, Spain) is a library and
     companion programs written and designed  to  take  the  heat  out  of
     designing  a  GENETIC  ALGORITHM.   It  features  a class library for
     genetic algorithm programming, but, from the user point of view, is a
     genetic  algorithm application generator. Just write the function you
     want to optimize, and GAGS surrounds it with enough code  to  have  a
     genetic  algorithm  up and running, compiles it, and runs it. GAGS Is
     written in C++, so that it can be compiled in  any  platform  running
     this   GNU   utility.   It  has  been  tested  on  various  machines.
     Documentation is available.

     GAGS includes:

     o  Steady-state, roulette-wheel, tournament and elitist SELECTION.

     o  FITNESS evaluation using training files.

     o  Graphics output through gnuplot.

     o  Uniform and 2-point CROSSOVER, and bit-flip and gene-transposition
	MUTATION.

     o  Variable length CHROMOSOMEs and related operators.

     The  application  generator  gags.pl  is  written  in  perl,  so this
     language must also be installed before GAGS. Available by  FTP  from:
     kal-el.ugr.es:/pub/GAGS-0.92.tar.gz The programmer's manual is in the
     same directory, file gagsprogs.ps.gz.  GAGS is  also  available  from
     ENCORE   (see   Q15.3)   in   file   EC/GA/src/gags-0.92.tar.gz  with
     documentation in EC/GA/docs/gagsprog.ps.gz

     Maintained by J.J. Merelo, Grupo Geneura, Univ. Granada <jmerelo@kal-
     el.ugr.es>

 GAlib:
     GAlib  is a C++ library that provides the application programmer with
     a set of GENETIC ALGORITHM  objects.   With  GAlib  you  can  add  GA
     OPTIMIZATION  to  your  program  using  any  data  representation and
     standard or  custom  SELECTION,  CROSSOVER,  MUTATION,  scaling,  and
     replacement, and termination methods.  View the documentation on-line
     at  http://lancet.mit.edu:/ga/  There  you  will  find   a   complete
     description of the programming interface, features, and examples.

     The   canonical   source   for   this   library   is  the  FTP  site:
     lancet.mit.edu:/pub/ga/ This directory contains UNIX (.tar.gz), MacOS
     (.sea.hqx), and DOS (.zip) versions of the GA library.  Once you have
     downloaded the file, uncompress and extract it.  It  will  expand  to
     its own directory.  If you extract the DOS version be sure to use the
     -d option to keep everything in one directory.

     GAlib requires a cfront 3.0 compatible C++  compiler.   It  has  been
     used  on the following systems: SGI IRIX 4.0.x (Cfront); SGI IRIX 5.x
     (DCC 1.0, g++ 2.6.8, 2.7.0); IBM RSAIX 3.2 (g++  2.6.8,  2.7.0);  DEC
     MIPS  ultrix  4.2  (g++  2.6.8,  2.7.0);  SUN SOLARIS 5.3 (g++ 2.6.8,
     2.7.0);  HP-UX  (g++);  MacOS  (MetroWerks  CodeWarrior   5);   MacOS
     (Symantec THINK C++ 7.0); DOS/Windows (Borland Turbo C++ 3.0).

     Maintained by: Matthew Wall <mbwall@mit.edu>
 GALOPPS:
     GALOPPS (Genetic Algorithm Optimized for Portability and Parallelism)
     is a general-purpose parallel GENETIC ALGORITHM  system,  written  in
     'C',  organized  like  Goldberg's  "Simple  Genetic Algorithm".  User
     defines objective function (in template furnished) and  any  callback
     functions  desired  (again, filling in template); can run one or many
     subpopulations, on one or many PC's, workstations, Mac's, MPP.   Runs
     interactively  (GUI or answering questions) or from files, makes file
     and/or graphical output.  Runs easily interrupted and restarted,  and
     a  PVM  version  for Unix networks even moves processes automatically
     when workstations become busy.  (Note: optional GUI requires Tcl/Tk.)
     14  example  problems  included (De Jong Functions, Royal Road, BTSP,
     etc.  )

     User may choose:

     o  problem type (permutation or value-type)

     o  field sizes (arbitrary, possibly  unequal,  heeded  by  CROSSOVER,
	MUTATION)

     o  among 7 crossover types and 4 mutation types (or define own)

     o  among  6  SELECTION  types,  including "automatic" option based on
	Boltzmann  scaling  and  Shapiro  and   Pruegel-Bennett   statist.
	Mechanics stuff

     o  operator   probabilities,   FITNESS  scaling,  amount  of  output,
	MIGRATION frequency and patterns,

     o  stopping criteria (using "standard" convergence STATISTICS,  etc.)

     o  the GGA (Grouping Genetic Algorithm) REPRODUCTION and operators of
	Falkenauer

     GALOPPS allows and supports:

     o  use of a different  representation  in  each  subpopulation,  with
	transformation of migrants

     o  INVERSION  on  level of subpopulations, with automatic handling of
	differing field sizes, migrants

     o  control over replacement by OFFSPRING, including  DeJong  crowding
	or random replacement or SGA-like replacement of PARENTs

     o  mate selection, using incest reduction

     o  migrant  selection, using incest reduction, and/or DeJong crowding
	into receiving subpopulation

     o  optional ELITISM

     Generic (Unix) GALOPPS 3.2 (includes 80-pp. manual) is  available  on
     ENCORE;  PVM GALOPPS, PC version (different line endings, makefiles),
     Threaded GALOPPS, and GALOPPS-based 2-level adaptive  system  at  the
     MSU         GARAGe         web         and         FTP         sites:
     http://isl.msu.edu/GA/software/software-index.html                  ,
     isl.msu.edu/pub/GA/galopps .

     Contact:  Erik  D.  Goodman,  <goodman@egr.msu.edu>, MSU GARAGe, Case
     Center, 112 Engineering Building, MSU, East Lansing, MI 48824 USA.

 GAMusic:
     GAMusic 1.0 is a user-friendly interactive demonstration of a  simple
     GA  that  evolves  musical  melodies.   Here, the user is the FITNESS
     function.  Melodies from  the  POPULATION  can  be  played  and  then
     assigned  a fitness.  Iteration, RECOMBINATION frequency and MUTATION
     frequency are all controlled by the user.  This program  is  intended
     to  provide  an introduction to GAs and may not be of interest to the
     experienced GA programmer.

     GAMusic was programmed with Microsoft Visual Basic  3.0  for  Windows
     3.1x.  No  special sound card is required.  GAMusic is distributed as
     shareware  (cost   $10)   and   can   be   obtained   by   FTP   from
     wuarchive.wustl.edu:/pub/MSDOS_UPLOADS/GenAlgs/gamusic.zip   or  from
     fly.bio.indiana.edu:/science/ibmpc/gamusic.zip The  program  is  also
     available from the America Online archive.

     Contact:    Jason    H.    Moore   <jhm@superh.hg.med.umich.edu>   or
     <jasonUMICH@aol.com>

 GANNET:
     GANNET (Genetic Algorithm / Neural NETwork)  is  a  software  package
     written  by  Jason Spofford in 1990 which allows one to evolve neural
     networks. It offers a variety of  configuration  options  related  to
     rates of the GENETIC OPERATORs.  GANNET evolves nets based upon three
     FITNESS functions:  Input/Output Accuracy,  Output  'Stability',  and
     Network Size.

     The  evolved  neural  network presently has a binary input and binary
     output format, with neurodes that have  either  2  or  4  inputs  and
     weights  ranging from -3 to +4.  GANNET allows for up to 250 neurodes
     in a net. Research using GANNET is continuing.

     GANNET is available by FTP  from  fame.gmu.edu:/gannet/source/  There
     are  separate directories for GANNET itself, a verifier program which
     verifies the best neural network  generated  (/gannet/verifier),  and
     some sample datasets (/gannet/datasets).  Further, Spofford's masters
     thesis  descrribing  GANNET  is  available   in   postscript   format
     (/gannet/thesis).

     Contact: Darrell Duane or Dr. Kenneth Hintz, George Mason University,
     Dept. of Electrical &  Computer  Engineering,  Mail  Stop  1G5,  4400
     University    Drive,    Fairfax,    VA     22033-4444    USA.    Net:
     <dduane@fame.gmu.edu> or <khintz@fame.gmu.edu>

 GAucsd:
     GAucsd is a Genesis-based GA package incorporating numerous bug fixes
     and  user  interface  improvements. Major additions include a wrapper
     that simplifies the writing of evaluation functions,  a  facility  to
     distribute   experiments  over  networks  of  machines,  and  Dynamic
     Parameter Encoding, a  technique  that  improves  GA  PERFORMANCE  in
     continuous   SEARCH   SPACEs   by  adaptively  refining  the  genomic
     representation of real-valued parameters.

     GAucsd was written in C for Unix systems, but the central  GA  engine
     is easily ported to other platforms. The entire package can be ported
     to systems where implementations of the Unix utilities "make",  "awk"
     and "sh" are available.

     GAucsd is available by FTP from cs.ucsd.edu:/pub/GAucsd/GAucsd14.sh.Z
     or from ftp.aic.nrl.navy.mil:/pub/galist/src/ga/GAucsd14.sh.Z  To  be
     added  to  a  mailing list for bug reports, patches and updates, send
     "add GAucsd" to <listserv@cs.ucsd.edu>.

     Cognitive Computer Science Research Group, CSE Department, UCSD 0114,
     La Jolla, CA 92093-0114, USA.  Net: <GAucsd-request@cs.ucsd.edu>

 GECO:
     GECO  (Genetic  Evolution  through  Combination  of  Objects)  is  an
     extensible,  object-oriented  framework   for   prototyping   GENETIC
     ALGORITHMs  in  Common  Lisp.  GECO  makes extensive use of CLOS, the
     Common Lisp  Object  System,  to  implement  its  functionality.  The
     abstractions provided by the classes have been chosen with the intent
     both of being easily  understandable  to  anyone  familiar  with  the
     paradigm  of  genetic  algorithms,  and  of  providing  the algorithm
     developer with the ability to customize all aspects of its operation.
     It  comes  with  extensive documentation, in the form of a PostScript
     file, and some simple examples are also provided  to  illustrate  its
     intended use.

     GECO   Version   2.0   is   available   by   FTP.    See   the   file
     ftp.aic.nrl.navy.mil:/pub/galist/src/ga/GECO-v2.0.README   for   more
     information.

     George  P.  W.  Williams, Jr., 1334 Columbus City Rd., Scottsboro, AL
     35768.  Net: <george@hsvaic.hv.boeing.com>.

 Genesis:
     Genesis  is  a  generational  GA  system  written  in   C   by   John
     Grefenstette.  As  the  first widely available GA program Genesis has
     been very influential in stimulating the  use  of  GAs,  and  several
     other GA packages are based on it. Genesis is available together with
     OOGA       (see       below),       or       by       FTP        from
     ftp.aic.nrl.navy.mil:/pub/galist/src/ga/genesis.tar.Z     (Unverified
     8/94).

 GENEsYs:
     GENEsYs  is  a  Genesis-based  GA   implementation   which   includes
     extensions  and  new  features  for  experimental  purposes,  such as
     SELECTION   schemes   like   linear    ranking,    Boltzmann,    (mu,
     lambda)-selection,   and   general   extinctive  selection  variants,
     CROSSOVER operators like n-point and uniform  crossover  as  well  as
     discrete and intermediate RECOMBINATION.  SELF-ADAPTATION of MUTATION
     rates is also possible.

     A set  of  objective  functions  is  provided,  including  De  Jong's
     functions,  complicated  continuous  functions, a TSP-problem, binary
     functions, and a fractal function. There are  also  additional  data-
     monitoring facilities such as recording average, variance and skew of
     OBJECT VARIABLES and mutation rates, or creating bitmap-dumps of  the
     POPULATION.

     GENEsYs   1.0   is   available  via  FTP  from  lumpi.informatik.uni-
     dortmund.de:/pub/GA/src/GENEsYs-1.0.tar.Z The documentation alone  is
     available as /pub/GA/docs/GENEsYs-1.0-doc.tar.Z

     For more information contact: Thomas Baeck, Systems Analysis Research
     Group, LSXI, Department of Computer Science, University of  Dortmund,
     D-44221    Dortmund,   Germany.    Net:   <baeck@ls11.informatik.uni-
     dortmund.de> (Unverified 8/94).

 GenET:
     GenET is a "generic" GA package.  It is generic in the sense that all
     problem  independent mechanisms have been implemented and can be used
     regardless of application  domain.   Using  the  package  forces  (or
     allows,  however  you  look  at it) concentration on the problem: you
     have to suggest the best representation, and the best  operators  for
     such  space that utilize your problem-specific knowledge.  You do not
     have to think about possible GA models or their implementation.

     The package, in addition  to  allowing  for  fast  implementation  of
     applications  and being a natural tool for comparing different models
     and strategies, is intended to become a depository of representations
     and  operators.   Currently,  only  floating  point representation is
     implemented in the library with few operators.

     The algorithm provides a wide selection of models  and  choices.  For
     example,  POPULATION  models  range  from  generational  GA,  through
     steady-state,  to  (n,m)-EP  and  (n,n+m)-EP  models  (for  arbitrary
     problems,  not  just parameter OPTIMIZATION).  (Some are not finished
     at the moment).  Choices include  automatic  adaptation  of  operator
     probabilities and a dynamic ranking mechanism, etc.

     Even  though  the  implementation  is  far  from optimal, it is quite
     efficient - implemented in ATT's C++ (3.0)  (functional  design)  and
     also  tested  on  gcc.   Along  with  the  package  you  will get two
     examples.  They   illustrate   how   to   implement   problems   with
     heterogeneous and homogeneous structures, with explicit rep/opers and
     how to use the existing library (FP).  Very soon I will  place  there
     another  example  -  our  GENOCOP  operators for linearly constrained
     optimization.  One more example soon to  appear  illustrates  how  to
     deal  with complex structures and non-stationary problems - this is a
     fuzzy rule-based controller optimized  using  the  package  and  some
     specific rep/operators.

     If  you  start using the package, please send evaluations (especially
     bugs) and suggestions for future versions to the author.

     GenET    Version    1.00     is     available     by     FTP     from
     radom.umsl.edu:/var/ftp/GenET.tar.Z  To  learn  more, you may get the
     User's   Manual,    available    in    compressed    postscript    in
     "/var/ftp/userMan.ps.Z".  It  also  comes  bundled  with the complete
     package.

     Cezary Z. Janikow, Department of Math and CS, CCB319, St.  Louis,  MO
     63121, USA.  Net: <janikow@radom.umsl.edu>

 Genie:
     Genie  is  a  GA-based  modeling/forecasting  system that is used for
     long-term planning. One can construct a model of an  ENVIRONMENT  and
     then  view the forecasts of how that environment will evolve into the
     future. It is then possible  to  alter  the  future  picture  of  the
     environment  so as to construct a picture of a desired future (I will
     not enter into arguments of who  is  or  should  be  responsible  for
     designing  a  desired  or  better future). The GA is then employed to
     suggest changes to the  existing  environment  so  as  to  cause  the
     desired future to come about.

     Genie  is  available free of charge via e-mail or on 3.5'' disk from:
     Lance Chambers, Department of Transport, 136 Stirling Hwy,  Nedlands,
     West  Australia  6007.  Net: <pstamp@yarrow.wt.uwa.edu.au> It is also
     available by FTP from hiplab.newcastle.edu.au:/pub/Genie&Code.sea.Hqx

 Genitor:
     "Genitor  is  a  modular GA package containing examples for floating-
     point, integer, and binary representations. Its features include many
     sequencing operators as well as subpopulation modeling.

     The  Genitor  Package  has  code  for  several  order based CROSSOVER
     operators, as well as example code  for  doing  some  small  TSPs  to
     optimality.

     We  are  planning  to release a new and improved Genitor Package this
     summer (1993), but it will mainly be additions to the current package
     that will include parallel island models, cellular GAs, delta coding,
     perhaps CHC (depending on the legal issues) and some other things  we
     have found useful."

     Genitor  is available from Colorado State University Computer Science
     Department by FTP from ftp.cs.colostate.edu:/pub/GENITOR.tar

     Please     direct     all     comments     and      questions      to
     <mathiask@cs.colostate.edu>.   If  these  fail  to  work, contact: L.
     Darrell  Whitley,  Dept.  of   Computer   Science,   Colorado   State
     University,     Fort     Collins,     CO     80523,     USA.     Net:
     <whitley@cs.colostate.edu> (Unverified 8/94).

 GENlib:
     GENlib is a library of functions for  GENETIC  ALGORITHMs.   Included
     are two applications of this library to the field of neural networks.
     The first one called "cosine" uses a genetic  algorithm  to  train  a
     simple three layer feed-Forward network to work as a cosine-function.
     This task is very difficult to train for a backprop  algorithm  while
     the  genetic  algorithm produces good results.  The second one called
     "vartop" is developing a Neural Network to perform the  XOR-function.
     This  is done with two genetic algorithms, the first one develops the
     topology of the network, the second one adjusts the weights.

     GENlib  may  be  obtained  by  FTP   from   ftp.neuro.informatik.uni-
     kassel.de:/pub/NeuralNets/GA-and-NN/

     Author:   Jochen  Ruhland,  FG  Neuronale  Netzwerke  /  Uni  Kassel,
     Heinrich-Plett-Str.      40,      D-34132      Kassel,       Germany.
     <jochenr@neuro.informatik.uni-kassel.de>

 GENOCOP:
     This  is  a  GA-based OPTIMIZATION package that has been developed by
     Zbigniew Michalewicz and is described in detail in his  book  Genetic
     Algorithms + Data Structures = Evolution Programs [MICHALE94].

     GENOCOP (Genetic Algorithm for Numerical Optimization for COnstrained
     Problems) optimizes a function with any number of linear  constraints
     (equalities and inequalities).

     The   second   version  of  the  system  is  available  by  FTP  from
     ftp.uncc.edu:/coe/evol/genocop2.tar.Z

     Zbigniew Michalewicz, Dept. of Computer Science, University of  North
     Carolina, Chappel-Hill, NC, USA.  Net: <zbyszek@uncc.edu>

 GIGA:
     GIGA is designed to propogate information through a POPULATION, using
     CROSSOVER as its operator. A discussion of how it propogates BUILDING
     BLOCKs,  similar  to  those  found  in  Royal  Road functions by John
     Holland, is given in the DECEPTION section of: "Genetic Invariance: A
     New  Paradigm  for  Genetic  Algorithm Design." University of Alberta
     Technical  Report  TR92-02,  June  1992.   See  also:  "GIGA  Program
     Description  and  Operation"  University of Alberta Computing Science
     Technical Report TR92-06, June 1992

     These  can  be  obtained,  along  with  the  program,  by  FTP   from
     ftp.cs.ualberta.ca:/pub/TechReports/  in  the subdirectories TR92-02/
     and TR92-06/ .

     Also, the paper "Mutation-Crossover Isomorphisms and the Construction
     of  Discriminating  Functions"  gives  a  more  in-depth  look at the
     behavior      of      GIGA.      Its      is      available      from
     ftp.cs.ualberta.ca:/pub/joe/Preprints/xoveriso.ps.Z
     Joe Culberson, Department of Computer Science, University of Alberta,
     CA.  Net: <joe@cs.ualberta.ca>

 GPEIST:
     The GENETIC PROGRAMMING ENVIRONMENT in Smalltalk (GPEIST) provides  a
     framework  for  the  investigation  of  Genetic  Programming within a
     ParcPlace  VisualWorks  2.0  development  system.   GPEIST   provides
     program,  POPULATION,  chart  and  report  browsers and can be run on
     HP/Sun/PC (OS/2 and Windows) machines. It is possible  to  distribute
     the  experiment  across  several  workstations  -  with subpopulation
     exchange  at  intervals  -  in  this  release   4.0a.    Experiments,
     populations  and INDIVIDUAL genetic programs can be saved to disk for
     subsequent analysis and experimental statistical  measures  exchanged
     with  spreadsheets.  Postscript  printing  of  charts,  programs  and
     animations is supported. An implementation of the Ant  Trail  problem
     is provided as an example of the use of the GPEIST environment.

     GPEIST    is   available   from   ENCORE   (see   Q15.3)   in   file:
     EC/GP/src/GPEIST4.tar.gz

     Contact: Tony White, Bell-Northern Research Ltd.,  Computer  Research
     Lab  -  Gateway,  320 March Road, Suite 400, Kanata, Ontario, Canada,
     K2K 2E3. tel: (613) 765-4279 <arpw@bnr.ca>

 Imogene:
     Imogene is a Windows 3.1 shareware  program  which  generates  pretty
     images  using  GENETIC PROGRAMMING.  The program displays GENERATIONs
     of 9 images, each generated using a formula applied  to  each  pixel.
     (The  formulae are initially randomly computed).  You can then select
     those images you prefer.  In the next generation, the nine images are
     generated  by  combining  and  mutating  the  formulae  for the most-
     preferred images  in  the  previous  generation.   The  result  is  a
     SIMULATION  of  natural  SELECTION in which images evolve toward your
     aesthetic preferences.

     Imogene supports different  color  maps,  palette  animation,  saving
     images to .BMP files, changing the wallpaper to nice images, printing
     images, and several other features. Imogene works only in  256  color
     mode  and  requires  a floating point coprocessor and a 386 or better
     CPU.

     Imogene  is  based  on  work  originally  done  by   Karl   Sims   at
     (ex-)Thinking Machines for the CM-2 massively parallel computer - but
     you  can  use  it  on  your   PC.   You   can   FTP   Imogene   from:
     ftp.io.com:/pub/genetic-programming/code/imogenes.zip

     Contact:  Harley  Davis,  ILOG  S.A.,  2 Avenue Gallini, BP 85, 94253
     Gentilly Cedex, France. tel: +33 1 46 63 66 66  <davis@ilog.fr>

 JAG:
     This Java program implements a simple  GENETIC  ALGORITHM  where  the
     FITNESS  function takes non-negative values only. It employs ELITISM.
     The Java code was derived from the C code in the Appendix of  Genetic
     Algorithms  +  Data  Structures  =  Evolution  Programs, [MICHALE94].
     Other ideas and code were drawn from GAC by Bill Spears.

     Four sample problems are contained in the code: three with bit  GENEs
     and  one  with  double  genes.  To use this program, modify the class
     MyChromosome to include your problem, which you have  coded  in  some
     class,  say  YourChromosome.  All changes to the sGA.java file to run
     your problem are confined to your class YourChromosome.  This is what
     object-oriented  programming  is all about!  The sGA.java source code
     file has a big comment at the end containing some sample runs.
     Available by FTP from  mcs.drexel.edu/pub/shartley/simpleGA.tar.gz  .
     Further       information      from      Stephen      J.      Hartley
     <shartley@mcs.drexel.edu>,   http://www.mcs.drexel.edu/~shartley    .
     Drexel University, Math and Computer Science Department Philadelphia,
     PA 19104 USA. +1-215-895-2678

 LibGA:
     LibGA is a library of routines written in C  for  developing  GENETIC
     ALGORITHMs.   It  is  fairly  simple to use, with many knobs to turn.
     Most GA parameters can be set or changed via  a  configuration  file,
     with  no  need to recompile. (E.g., operators, pool size and even the
     data type used in the CHROMOSOME can be changed in the  configuration
     file.)  Function pointers are used for the GENETIC OPERATORs, so they
     can easily be manipulated on the fly.  Several genetic operators  are
     supplied   and   it  is  easy  to  add  more.   LibGA  runs  on  many
     systems/architectures.  These include Unix, DOS, NeXT, and Amiga.

     LibGA    Version    1.00     is     available     by     FTP     from
     ftp.aic.nrl.navy.mil:/pub/galist/src/ga/libga100.tar.Z  or  by  email
     request to its author, Art Corcoran <corcoran@penguin.mcs.utulsa.edu>
     (Unverified 8/94).

 LICE:
     LICE   is   a  parameter  OPTIMIZATION  program  based  on  EVOLUTION
     STRATEGIEs (ES).  In  contrast  to  classic  ES,  LICE  has  a  local
     SELECTION scheme to prevent premature stagnation. Details and results
     were presented at the EP'94 conference in San Diego.  LICE is written
     in  ANSI-C  (more or less), and has been tested on Sparc-stations and
     Linux-PCs. If you want plots and graphics, you need X11 and  gnuplot.
     If you want a nice user interface to create parameter files, you also
     need Tk/Tcl.

     LICE-1.0   is   available   as    source    code    by    FTP    from
     lumpi.informatik.uni-dortmund.de:/pub/ES/src/LICE-1.0.tar.gz

     Author: Joachim Sprave <joe@ls11.informatik.uni-dortmund.de>

 Matlab-GA:
     The  MathWorks  FTP  site  has  some  Matlab GA code in the directory
     ftp.mathworks.com:/pub/contrib/optim/genetic It's a bunch of .m files
     that    implement    a    basic    GA.    Contact:   Andrew   Potvin,
     <potvin@mathworks.com> for information.

 mGA:
     mGA is an implementation of a messy GA as described  in  TCGA  report
     No.  90004.  Messy GAs overcome the linkage problem of simple GENETIC
     ALGORITHMs by combining  variable-length  strings,  GENE  expression,
     messy   operators,  and  a  nonhomogeneous  phasing  of  evolutionary
     processing.   Results  on  a  number  of  difficult  deceptive   test
     functions  have  been  encouraging  with  the messy GA always finding
     global optima in a polynomial number of function evaluations.

     See TCGA reports 89003, 90005, 90006, and 91004, and  IlliGAL  report
     91008  for  more  information  on messy GAs (See Q14). The C language
     version  is  available  by  FTP  from  IlliGAL   in   the   directory
     gal4.ge.uiuc.edu:/pub/src/messyGA/C/

 PARAGenesis:
     PARAGenesis  is  the result of a project implementing  Genesis on the
     CM-200 in C*. It is an attempt to  improve  PERFORMANCE  as  much  as
     possible  without  changing  the  behavior  of the GENETIC ALGORITHM.
     Unlike  the  punctuated  equilibria  and  local   SELECTION   models,
     PARAGenesis   doesn't   modify  the  genetic  algorithm  to  be  more
     parallelizable as  these  modifications  can  drastically  alter  the
     behavior  of  the  algorithm.  Instead  each  member  is  placed on a
     separate processor allowing initialization, evaluation  and  MUTATION
     to   be   completely  parallel.  The  costs  of  global  control  and
     communication in selection and CROSSOVER are present but minimized as
     much as possible. In general PARAGenesis on an 8k CM-200 seems to run
     10-100 times faster than Genesis on a Sparc 2  and  finds  equivalent
     solutions.

     PARAGenesis  includes  all  the  features of serial Genesis plus some
     additions. The  additions  include  the  ability  to  collect  timing
     STATISTICS, probabilistic selection (as opposed to Baker's stochastic
     universal sampling), uniform  crossover  and  local  or  neighborhood
     selection.  Anyone familiar with the serial implementation of Genesis
     and C* should have little problem using PARAGenesis.

     PARAGenesis       is       available        by        FTP        from
     ftp.aic.nrl.navy.mil:/pub/galist/src/ga/paragenesis.tar.Z

     DISCLAIMER:  PARAGenesis  is  fairly  untested  at this point and may
     contain some bugs.

     Michael van Lent, Advanced Technology Lab,  University  of  Michigan,
     1101    Beal    Av.,    Ann    Arbor,    MI    48109,    USA.    Net:
     <vanlent@eecs.umich.edu>.

 PGA:
     PGA is a simple testbed for basic explorations in GENETIC ALGORITHMs.
     Command  line  arguments  control  a range of parameters, there are a
     number of built-in problems for the GA  to  solve.  The  current  set
     includes:

     o  maximize the number of bits set in a CHROMOSOME

     o  De Jong's functions DJ1, DJ2, DJ3, DJ5

     o  binary F6, used by Schaffer et al

     o  a  crude  1-d  knapsack problem; you specify a target and a set of
	numbers in an external file, GA tries to find a subset  that  sums
	as closely as possible to the target

     o  the `royal road' function(s); a chromosome is regarded as a set of
	consecutive blocks of size K, and scores K for each block entirely
	filled with 1s, etc; a range of parameters.

     o  max contiguous bits, you choose the ALLELE range.

     o  timetabling,  with  various  smart  MUTATION  options;  capable of
	solving a good many real-world timetabling problems (has done so)

     Lots of GA options: rank, roulette, tournament,  marriage-tournament,
     spatially-structured  SELECTION;  one-point, two-point, uniform or no
     CROSSOVER; fixed or adaptive mutation; one child or two; etc.

     Default output is curses-based, with optional output to file; can  be
     run non-interactively too for batched series of experiments.

     It's  easy  to  add your own problems. chromosomes are represented as
     character arrays, so  you  are  not  (quite)  stuck  with  bit-string
     problem encodings.

     PGA  has  been  used  for teaching for a couple of years now, and has
     been used as a starting point by a fair number of  people  for  their
     own projects. So it's reasonably reliable. However, if you find bugs,
     or have useful contributions to make, Tell Me! It is available by FTP
     from   ftp.dai.ed.ac.uk:pub/pga-2.7/pga-2.7.tar.Z   (see   the   file
     pga.README in the same directory for more information)

     Peter Ross, Department of  AI,  University  of  Edinburgh,  80  South
     Bridge, Edinburgh EH1 1HN, UK.  Net: <peter@aisb.ed.ac.uk>

 PGAPack:
     PGAPack is a general-purpose, data-structure-neutral parallel GENETIC
     ALGORITHM library.  It  is  intended  to  provide  most  capabilities
     desired  in  a genetic algorithm library, in an integrated, seamless,
     and portable manner.

     Features include:

     o  Callable from Fortran or C.

     o  Runs  on  uniprocessors,  parallel  computers,   and   workstation
	networks.

     o  Binary-,  integer-,  and  real-  and  character-valued native data
	types

     o  Full extensibility to support custom operators and new data types.

     o  Easy-to-use interface for novice and application users.

     o  Multiple levels of access for expert users.

     o  Extensive debugging facilities.

     o  Large set of example problems.

     o  Detailed users guide

     o  Parameterized POPULATION replacement.

     o  Multiple choices for SELECTION, CROSSOVER, and MUTATION operators

     o  Easy integration of hill-climbing heuristics.

     Availability:  PGAPack is freely available and may be obtained by FTP
     from     info.mcs.anl.gov:/pub/pgapack/pgapack.tar.Z     or      from
     http://www.mcs.anl.gov/pgapack.html

     Further  Information  from  David  Levine,  Mathematics  and Computer
     Science Division,  Argonne  National  Laboratory,  Argonne,  Illinois
     60439,               (708)-252-6735              <levine@mcs.anl.gov>
     http://www.mcs.anl.gov:/home/levine

 REGAL:
     REGAL (RElational Genetic Algorithm Learner)  is  a  distributed  GA-
     based  system,  designed  for  learning multi-modal First Order Logic
     concept descriptions from examples.  REGAL is based  on  a  selection
     operator,  called  Universal Suffrage operator, provably allowing the
     population to asymptotically converge, on average, to an  equilibrium
     state,  in which several species coexist.  REGAL makes use of PVM 3.3
     and Tcl/Tk.  This version of REGAL is provided with a graphical  user
     interface developed in Tcl/Tk language.

     REGAL    has    been   jointly   developed   by:   Attilio   Giordana
     <attilio@di.unito.it>  http://www.di.unito.it/~attilio/  and  Filippo
     Neri    <neri@di.unito.it>   http://www.di.unito.it/~neri/   at   the
     University of Torino, Dipartimento di Informatica, Italy.

     See also:

      Neri  F.  and Giordana A. (1995). "A Distributed  Genetic  Algorithm
     for  Concept  Learning",  Proc.  Int.   Conf.   on Genetic Algorithms
     (Pittsburgh, PA), Morgan Kaufmann, pp. 436-443.
      Neri  F.  and  Saitta L. (1995). "A Formal  Analysis  of
      Selection  Schemes".  Proc.   Int.   Conf.   on  Genetic  Algorithms
     (Pittsburgh,PA), Morgan Kaufmann, pp. 32-39 .

      Giordana A. and Neri F. (1996). "Search-Intensive Concept
      Induction".  Evolutionary Computation
      Journal, MIT Press, vol. 3, n. 4, pp. 375 - 416.

      Neri F. and  Saitta L. (1997). "An Analysis of the
      Universal Suffrage Selection Operator".  Evolutionary Computation
      Journal, MIT Press, vol. 4, n. 1, pp. 89-109.

 SGA-C, SGA-Cube:
     SGA-C  is  a  C-language  translation  and  extension of the original
     Pascal SGA code presented in Goldberg's book [GOLD89].  It  has  some
     additional  features,  but  its  operation is essentially the same as
     that of the Pascal version. SGA-C is described  in  TCGA  report  No.
     91002.

     SGA-Cube  is  a  C-language  translation  of Goldberg's SGA code with
     modifications to allow execution on the nCUBE  2  Hypercube  Parallel
     Computer.   When  run  on the nCUBE 2, SGA-Cube can take advantage of
     the  hypercube  architecture,  and  is  scalable  to  any   hypercube
     dimension.  The  hypercube  implementation  is  modular,  so that the
     algorithm for exploiting parallel processors can be easily  modified.

     In addition to its parallel capabilities, SGA-Cube can be compiled on
     various serial computers via  compile-time  options.  In  fact,  when
     compiled  on  a serial computer, SGA-Cube is essentially identical to
     SGA-C.  SGA-Cube  is described in TCGA report No. 91005.

     Each of these programs is distributed in the  form  of  a  Unix  shar
     file,  available  via e-mail or on various formatted media by request
     from: Robert Elliott Smith, Department of Engineering  of  Mechanics,
     Room  210  Hardaway Hall,, The University of Alabama P.O. Box 870278,
     Tuscaloosa, Alabama 35487, USA.  Net: <rob@comec4.mh.ua.edu>

     SGA-C and SGA-Cube are also available in compressed tar form  by  FTP
     from   ftp.aic.nrl.navy.mil:/pub/galist/src/ga/sga-c.tar.Z  and  sga-
     cube.tar.Z .

 Splicer:
     Splicer  is  a  GENETIC  ALGORITHM  tool  created  by  the   Software
     Technology  Branch  (STB)  of  the Information Systems Directorate at
     NASA/Johnson Space Center with support from  the  MITRE  Corporation.
     Splicer   has   well-defined   interfaces   between   a   GA  kernel,
     representation  libraries,  FITNESS  modules,  and   user   interface
     libraries.

     The   representation   libraries   contain  functions  for  defining,
     creating, and decoding genetic strings, as well as multiple CROSSOVER
     and  MUTATION  operators.  Libraries  supporting  binary  strings and
     permutations are provided, others can be created by the user.

     Fitness modules are typically written  by  the  user,  although  some
     sample  applications  are provided. The modules may contain a fitness
     function, initial  values  for  various  control  parameters,  and  a
     function which graphically displays the best solutions.

     Splicer  provides  event-driven  graphic user interface libraries for
     the Macintosh and the X11 window system (using the HP widget set);  a
     menu-driven  ASCII  interface  is  also  available  though  not fully
     supported.  The extensive documentation includes a  reference  manual
     and  a  user's  manual;  an  architecture  manual  and  the  advanced
     programmer's manual are currently being written.

     An  electronic  bulletin  board  (300/1200/2400   baud,   8N1)   with
     information  regarding  Splicer  can  be reached at (713) 280-3896 or
     (713)  280-3892.   Splicer  is  available  free  to  NASA   and   its
     contractors  for  use  on government projects by calling the STB Help
     Desk weekdays 9am-4pm CST at (713) 280-2233.  Government  contractors
     should have their contract monitor call the STB Help Desk; others may
     purchase Splicer for $221 (incl. documentation) from: COSMIC, 382  E.
     Broad  St.,  Athens,  GA  30602, USA.  (Unverified 8/94).  Last known
     address <bayer@galileo.jsc.nasa.gov> (Steve Bayer). This now  bounces
     back with "user unknown".

 TOLKIEN:
     TOLKIEN  (TOoLKIt  for  gENetics-based  applications)  is a C++ class
     library, intended for those involved in  GAs  and  CLASSIFIER  SYSTEM
     research  with  a  working knowledge of C++. It is designed to reduce
     effort in  developing  genetics-based  applications  by  providing  a
     collection   of  reusable  objects.   For  portability,  no  compiler
     specific or class library specific features are  used.   The  current
     version  has been compiled successfully using Borland C++ Version 3.1
     and GNU C++.

     TOLKIEN contains a lot of useful extensions to  the  generic  GENETIC
     ALGORITHM  and classifier system architecture.  Examples include: (i)
     CHROMOSOMEs of user-definable types; binary, character,  integer  and
     floating  point;  (ii)  Gray code encoding and decoding; (iii) multi-
     point and uniform CROSSOVER; (iv) diploidy and dominance; (v) various
     SELECTION  schemes  such  as tournament selection and linear ranking;
     (vi) linear FITNESS scaling and sigma truncation; (vii) the  simplest
     one-taxon-one-action  classifiers and the general two-taxa-one-action
     classifiers.

     TOLKIEN   is   available   from   ENCORE   (See   Q15.3)   in   file:
     GA/src/TOLKIEN.tar.gz  The  documentation  and  two primers on how to
     build   GA   and   CFS   applications   alone   are   available   as:
     GA/docs/tolkien-doc.tar.gz

     Author:  Anthony  Yiu-Cheung Tang <tang028@cs.cuhk.hk>, Department of
     Computer Science (Rm 913), The Chinese University of Hong Kong.  Tel:
     609-8403, 609-8404.

 Trans-Dimensional Learning:
     This  is  a  Windows  3.1  artificial  neural  netwrk  and GA program
     (shareware).  TDL v1.0 allows users to perform pattern recognition by
     utilizing  software  that  allows for fast, automatic construction of
     Neural Networks, mostly alleviating the need  for  parameter  tuning.
     Evolutionary  processes  combined with semi-weighted networks (hybrid
     cross  between  standard  weighted  neurons  and  weightless  n-level
     threshold units) generally yield very compact networks (i.e., reduced
     connections and hidden units). By supporting multi-shot learning over
     standard  one-shot  learning,  multiple  data  sets (characterized by
     varying input and output dimensions) can  be  learned  incrementally,
     resulting  in  a  single  coherent  network.   This  can also lead to
     significant improvements in  predictive  accuracy  (Trans-dimensional
     generalization).   Graphical  support and several data files are also
     provided.

     Available                by                 FTP                 from:
     oak.oakland.edu:/SimTel/win3/neurlnet/tdl10.zip also available on WWW
     from: http://www.acs.oakland.edu:/oak/SimTel/win3/neurlnet.html

     For further details contact: Steve Romaniuk <ZLXX69A@prodigy.com>

 WOLF:
     This is  a  simulator  for  the  G/SPLINES  (genetic  spline  models)
     algorithm which builds spline-based functional models of experimental
     data, using CROSSOVER and MUTATION to evolve a POPULATION  towards  a
     better  fit.  It is derived from Friedman's MARS models. The original
     work  was  presented  at  ICGA-4,  and  further   results   including
     additional basis function types such as B-splines have been presented
     at the NIPS-91 meeting.

     Available free by FTP by contacting the  author;  runs  on  SUN  (and
     possibly  any  SYSV) UNIX box. Can be redistributed for noncommercial
     use. Simulator includes executable and C  source  code;  a  technical
     report (RIACS tech report 91.10) is also available.

     David  Rogers, MS Ellis, NASA Ames Research Center, Moffett Field, CA
     94035, USA.  Net: <drogers@msi.com>

 CLASSIFIER SYSTEMS
 CFS-C:
     CFS-C 1.0 is a domain independent  collection  of  CLASSIFIER  SYSTEM
     routines written by Rick L. Riolo as part of his PhD dissertation.  A
     completely rewritten CFS-C is planned for 1994/95; this  may  include
     the  features  of  CFS-C  2.0  mentioned  in  [SAB90]  (e.g.  "latent
     learning") or they may be included in a separate package released  in
     1995.  An ANSIfied version of CFS-C 1.0 (CFS-C 1.98j) is available by
     FTP.

     CFS-C   is   available   from   ENCORE   (See   Q15.3)    in    file:
     CFS/src/cfsc-1.98j.tar.gz  and  includes  the  original 1.02 CFS-C in
     it's "cfsc/orig" folder after unpacking.  On  the  "SyS"  FTP  server
     it's: lumpi.informatik.uni-dortmund.de:/pub/LCS/src/cfsc-1.98j.tar.gz
     with documentation in /pub/LCS/docs/cfsc.ps.gz

     Another  version  of  CFS-C  (version   XV   0.1)   by   Jens   Engel
     <engel@asterix.irb.uni-hannover.de>  is also available. This includes
     bug fixes of earlier versions, allowing it to run on a wider range of
     machines  (e.g. Linux and nCUBE). It also has an XView front end that
     makes it easier to control, and some extensions  to  the  algorithms.
     It  is  available from Encore in file: CFS/src/cfscxv-0.1.tar.gz with
     documentation in CFS/docs/cfscxv-0.1.readme.gz

     References

     Rick  L.  Riolo  (1988)  "CFS-C:  A  package  of  domain  independent
     subroutines  for  implementing classifier systems in arbitrary, user-
     defined environments", Logic of computers group, Division of computer
     science and engineering, University of Michigan.

     Rick  L.  Riolo  (1988)  "LETSEQ:  An  implementation  of  the  CFS-C
     classifier-system in a task-domain that involves learning to  predict
     letter  sequences",  Logic  of  computers group, Division of computer
     science and engineering, University of Michigan.

     Rick L. Riolo (1988) "CFS-C/FSW1:  An  implementation  of  the  CFS-C
     classifier system in a task domain that involves learning to traverse
     a finite state world", Logic of computers group, Division of computer
     science and engineering, University of Michigan.

 SCS-C:
     SCS-C  is  a  (`mostly ANSI') C language translation and extension of
     Goldberg's Simple CLASSIFIER SYSTEM, as presented in  Appendix  D  in
     his seminal book [GOLD89].

     SCS-C  has been developed in parallel on a Sun 10/40 and an ATARI ST,
     and thus should be quite portable; it's distributed  free  of  charge
     under  the terms of the GNU General Public License. Included are some
     additional goodies, e.g. the VAX/VMS version of SCS, rewritten  in  C
     by Erik Mayer <emayer@uoft02.utoledo.edu>.

     SCS-C  v1.0j  is  available  from  ENCORE (See Q15.3), by FTP in file
     EC/CFS/src/scsc-1.0j.tar.gz

     For more information contact: Joerg  Heitkoetter,  EUnet  Deutschland
     GmbH,  Techo-Park,  Emil-Figge-Str.  80,  D-44227  Dortmund, Germany.
     Net: <joke@Germany.EU.net>.

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

Subject: Q20.2: Commercial software packages?

 EnGENEer:
     Logica Cambridge Ltd.  developed  EnGENEer  as  an  in-house  GENETIC
     ALGORITHM environment to assist the development of GA applications on
     a wide range of domains. The software was written in C and runs under
     Unix  as  part of a consultancy and systems package. It supports both
     interactive (X-Windows) and batch (command-line) modes of  operation.

     EnGENEer  provides  a  number  of flexible mechanisms which allow the
     developer to rapidly bring the power of GAs to bear  on  new  problem
     domains.   Starting   with  the  Genetic  Description  Language,  the
     developer can describe, at high level, the structure of the ``genetic
     material''  used.  The  language  supports  discrete  GENEs with user
     defined  cardinality  and  includes   features   such   as   multiple
     CHROMOSOMEs models, multiple SPECIES models and non-evolvable parsing
     symbols which can be used for decoding complex genetic material.

     The user also has available a descriptive high  level  language,  the
     Evolutionary Model Language. It allows the description of the GA type
     used in terms of configurable  options  including:  POPULATION  size,
     population  structure  and  source,  SELECTION  method, CROSSOVER and
     MUTATION type  and  probability,  INVERSION,  dispersal  method,  and
     number of OFFSPRING per GENERATION.

     Both  the  Genetic  Description  Language  and the Evolutionary Model
     Language  are  fully  supported  within  the  interactive   interface
     (including online help system) and can be defined either "on the fly"
     or loaded from audit files which are automatically created  during  a
     GA run.

     Monitoring  of  GA  progress is provided via both graphical tools and
     automatic storage of results (at user defined intervals). This allows
     the user to restart EnGENEer from any point in a run, by loading both
     the population at that time and the evolutionary model that was being
     used.

     Connecting  EnGENEer  to  different  problem  domains  is achieved by
     specifying the name of the  program  used  to  evaluate  the  problem
     specific  FITNESS  function and constructing a simple parsing routine
     to  interpret  the  genetic   material.   A   library   of   standard
     interpretation   routines   are   also  provided  for  commonly  used
     representation schemes such as gray-coding,  permutations,  etc.  The
     fitness  evaluation  can then be run as either a slave process to the
     GA or via a standard handshaking routines. Better still,  it  can  be
     run  on  either the machine hosting the EnGENEer or on any sequential
     or parallel hardware capable of connecting to a Unix machine.

     For more information, contact: George Robbins,  Systems  Intelligence
     Division,  Logica  Cambridge  Ltd.,  Betjeman  House, 104 Hills Road,
     Cambridge CB2 1LQ, UK.  Tel: +44 1716 379111, Fax:  +44  1223  322315
     (Unverified 8/94).

 EvoFrame:
     EvoFrame  is  to  EVOLUTION  STRATEGIEs  what  MicroGA  is to GENETIC
     ALGORITHMs, a toolkit for application development  incorporating  ESs
     as the OPTIMIZATION engine.

     EvoFrame  is  an  object  oriented  implemented  programming tool for
     evolution  strategies   (Rechenberg/Schwefel,   Germany)   for   easy
     implementation and solution of numerical and combinatorical problems.
     EvoFrame  gives  you  freedom  of  implementing  every  byte  of  the
     optimization  principle  and its user interface. You can focus on the
     optimization problem and forget about all the rest.

     EvoFrame is available as Version 2.0 in Borland-Pascal 7.0 and Turbo-
     Vision  for  PC's and as Version 1.0 in C++ for Apple Macintosh using
     MPW   and   MacApp.    Both   implementations   allow   full    typed
     implementation,  i.e.   no  more  translation  from  problem specific
     format to an optimization  specific  one.   A  prototyping  tool  (cf
     REALizer) exists for both platforms too.

     EvoFrame  allows pseudoparallel optimization of many problems at once
     and you can switch optimization parameters and internal methods (i.e.
     quality  function etc.) during runtime and during optimization cycle.
     Both tools can  be  modified  or  extended  by  overloading  existing
     methods  for  experimental  use.  They  are  developed continously in
     correlation to new research results.

     The  PC  version  is  prepared  for  experimental  use   due   to   a
     comprehensive  protocolling  mechanism of optimzation cycles and user
     data. It also allows compilation of executable files  with  different
     complexity  by  setting conditional compilation flags. It can be used
     with 3 levels of stacked POPULATIONs.

     The Mac version is the more complex  (recursive)  implementation.  It
     allows stacking of any number of populations for modelling of complex
     systems. Theory stops at multipopulation level at the time.  EvoFrame
     for  Mac  is  ready for the future, allowing any number of population
     levels.

     Ask for porting the Mac version (C++) to any other platform,  i.e.  X
     Windows.

     REALizer  is  a  tool for rapid prototyping of EvoFrame applications.
     It's an override of the corresponding framework which is prepared  to
     optimize  using  a  vector  of real numbers. All methods for standard
     EVOLUTION  and  file  handling,  etc.  are  ready  implemented.   The
     remaining  work  for the user is to define a constant for the problem
     size, fill  in  the  quality  function  and  start  the  optimization
     process.

     For  further information, current prices and orders, contact: Wolfram
     Stebel,  Optimum  Software,  Braunfelser  Str.  26,  35578   Wetzlar,
     Germany.  Net: <optimum@applelink.apple.com>

 Evolver:
     Evolver is a GENETIC ALGORITHM package for Windows. Beginners can use
     the Excel add-in to model  and  solve  problems  from  within  Excel.
     Advanced  users  can  use  the  included  Evolver API to build custom
     applications that access any of the six different genetic algorithms.
     Evolver can be customized and users can monitor progress in real-time
     graphs, or change  parameters  through  the  included  EvolverWatcher
     program.   The  $349  package  comes  on two 3.5" disks, and includes
     support for Visual  Basic.  For  further  information  or  to  order,
     contact: Palisade Corp, (607) 277-8000 http://www.palisade.com

 FlexTool:
     FlexTool(GA) is a modular software tool which provides an environment
     for applying GA to diverse domains with minimum user interaction  and
     design iteration.

     Version  M2.2  is  the MATLAB version which provides a total GA based
     design and development environment in MATLAB. MATLAB provides us with
     an  interactive  computation  intensive  environment. The high level,
     user friendly programming language combined with  built-in  functions
     to   handle  matrix  algebra,  Fourier  series,  and  complex  valued
     functions provides the power for large scale number crunching.

     The GA objects are provided as .m files. FlexTool(GA) Version M2.2 is
     designed with emphasis on modularity, flexibility, user friendliness,
     environment transparency, upgradability, and reliability. The  design
     is  engineered  to  evolve  complex,  robust models by drawing on the
     power of MATLAB.

     FlexTool(GA) Version M2.2 Features:
     BUILDING BLOCK          : Upgrade to EFM or ENM or CI within one year
     Niching module          : to identify multiple solutions
     Clustering module       : Use separately or with Niching module
     Optimization            : Single and Multiple Objectives
     Flex-GA                 : Very fast proprietary learning algorithm

     GA                      : Modular, User Friendly, and  System Transparent
     GUI                     : Easy to use, user friendly
     Help                    : Online
     Tutorial                : Hands-on tutorial, application guidelines
     Parameter Settings      : Default parameter settings for the novice
     General                 : Statistics, figures, and data collection
     Compatibility           : FlexTool product suite

     GA options              : generational, steady state, micro, Flex-GA
     Coding schemes          : include binary, logarithmic, real
     Selection               : tournament, roulette wheel, ranking
     Crossover               : include 1, 2, multiple point crossover
     Compatible to           : FlexTool(GA) M1.1 Genetic Algorithms Toolbox

     The FlexTool product suite includes various soft  computing  building
     blocks:
     CI: Computational Intelligence http://www.flextool.com/ftci.html
     EFM: Evolutionary Fuzzy Modeling http://www.flextool.com/ftefm.html
     ENM: Evolutionary Neuro Modeling http://www.flextool.com/ftenm.html
     FS : Fuzzy Systems http://www.flextool.com/ftfs.html
     EA : Evolutionary Algorithms http://www.flextool.com/ftga.html
     NN : Neural Networks http://www.flextool.com/ftnn.html

     For information contact <info@flextool.com> http://www.flextool.com

 GAME:
     GAME   (GA   Manipulation   Environment)   aims   to  demonstrate  GA
     applications and build a suitable programming ENVIRONMENT.

     GAME is being developed as  part  of  the  PAPAGENA  project  of  the
     European Community's Esprit III initiative.

     GAME  is  available  as  an  addendum to a book on PGAs (cf PAPAGENA,
     Q20.3).      And     from     the      project's      FTP      server
     bells.cs.ucl.ac.uk:/papagena/  e.g. "papagena/game/docs" contains all
     the papers that have been  produced  over  the  course  of  the  GAME
     project.    The   sources   can   also   be   obtained   by  FTP  see
     papagena/game/version2.01/

     GAME is now in version 2.01. This version is still able to  run  only
     sequential GAs, but version 3.0 will handle parallel GAs as well.
     Unfortunately,  The  project  yet  only  produced  a  Borland C++ 3.x
     version, so far.  It is intended to distribute a version for UNIX/GNU
     C++   as   well,   when  some  compatibility  issues  concerning  C++
     "standards" have been resolved. Afterward  a  UNIX  version  will  be
     released,  but  this  will  be  only  happen  after the release of PC
     version 3.0.

     For more information contact: Jose Luiz Ribeiro Filho, Department  of
     Computer  Science,  University  College  London, Gower Street, London
     WC1E 6BT, UK.  Net: <zeluiz@cs.ucl.ac.uk> (Unverified 8/94).

 GeneHunter:
     GeneHunter from Ward Systems runs  on  a  PC  under  Windows.  It  is
     callable  from  Microsoft  Excel  5  spreadsheets, and accessible via
     function calls in  a  dynamic  link  library.  The  DLL  is  designed
     especially for Visual Basic, but runs with other languages which call
     DLLs under Windows 3.1 such as Visual C++. 16-  and  32-bit  versions
     are  available.   GeneHunter  can  also  integrate with Ward's neural
     network software. Cost $369.

     For full details, see http://www.wardsystems.com/  or  contact:  Ward
     Systems Group Inc, Executive Park West, 5 Hillcrest Drive, Frederick,
     MD 21703, USA.  301-662-7950 <wardsystems@msn.com>

 Generator:
     GENERATOR is a GENETIC ALGORITHM package designed  to  interact  with
     Microsoft  Excel  for  Windows.   Users  are able to define and solve
     problems using Excel formulas,  tables  and  functions.   FITNESS  is
     easily  defined  as an Excel formula or optionally a macro.  Progress
     can be monitored using GENERATOR's real-time fitness graph and status
     window as well as user-defined Excel graphs.  GENERATOR can be paused
     at any time to allow adjustment of any of  the  parameters  and  then
     resumed.

     GENERATOR Features:

     o  Multiple GENE types: integer, real and permutation.

     o  Combined roulette-wheel and elitist SELECTION method.

     o  ELITISM is optional and adjustable.

     o  None, two-point, and a proprietary permutation CROSSOVER.

     o  Random,   Random  Hillclimb  and  Directional  Hillclimb  MUTATION
	methods.

     o  Special hillclimbing features to find solutions faster.

     o  fitness goal: maximize, minimize or seek value.

     o  Convergence: duplicates not allowed.

     o  Real-Time  alteration  of  parameters   relating   to   crossover,
	mutation, POPULATION, etc.

     o  Real-Time progress graph of Best, Worst and Median fitness.

     o  fitness defined using an Excel formula or macro.

     The parameters available to the user include mutation probability for
     population and genes, control of mutation limit per gene, control  of
     hillclimbing,   population  size,  elite  group  size,  RECOMBINATION
     method, and mutation technique.

     Connecting generator to problems defined on the Excel spreadsheet  is
     achieved  by  first  specifying the spreadsheet locations of the gene
     group cells and their type, and lastly, the location of  the  formula
     used to evaluate the problem-specific fitness function.

     GENERATOR requires at least a 386 IBM compatible PC with 2 MB of RAM,
     Windows 3.0 (or  later)  and  Microsoft  Excel  4.0  (or  later).   A
     comprehensive  manual  includes  an explanation of genetic algorithms
     and several tutorial example  problems.   The  $379  package.includes
     GENERATOR  on a 3.5" diskette, the manual, and free customer support.

     For further information or to order, contact: New  Light  Industries,
     Ltd.;  9713 W. Sunset Hwy; Spokane, WA USA 99204 Tel: (509) 456-8321;
     Fax  (509)   456-8351;   E-mail:   <nli@comtch.iea.com>   WWW   page:
     http://www.iea.com:/~nli

 MicroGA:
     MicroGA  is a powerful and flexible new tool which allows programmers
     to integrate GAs into their software quickly and  easily.  It  is  an
     object-oriented  C++  framework  that comes with full source code and
     documentation as well as three sample applications. Also included  is
     the  Galapagos  code  generator which allows users to create complete
     applications interactively without writing any C++ code, and a sample
     MacApp interface.

     MicroGA  is  available  for Macintosh II or higher with MPW and a C++
     compiler, and also in a Microsoft Windows version for PC compatibles.
     Compiled  applications  made with MicroGA can be sold without license
     fee. MicroGA is priced at $249.

     Galapagos is a tool for use with Emergent Behavior's MicroGA Toolkit.
     It  allows  a  user to define a function and set of constraints for a
     problem that the user wants to solve using the  GA.   Galapagos  then
     generates a complete C++ program using the information supplied. Then
     all the user has to do  is  to  compile  these  files,  using  either
     Turbo/Borland   C++  (PC,  MS  Windows),  or  MPW  and  C++  compiler
     (Macintosh), and link the resulting code to the MicroGA library. Then
     just  run  the  program.  Galapagos  comes  free  with  every copy of
     MicroGA.

     For further information and orders, contact: Steve  Wilson,  Emergent
     Behavior,  635  Wellsbury  Way,  Palo  Alto,  CA  94306,  USA.   Net:
     <emergent@aol.com>

     MicroGA is distributed in Germany by Optimum Software (cf EvoFrame  &
     REALizer entries).

 Omega:
     The  Omega  Predictive Modeling System, marketed by KiQ Limited, is a
     powerful  approach  to  developing  predictive  models.  It  exploits
     advanced GA techniques to create a tool which is "flexible, powerful,
     informative and straightforward to  use".  Omega  is  geared  to  the
     financial  domain,  with applications in Direct Marketing, Insurance,
     Investigations  and  Credit  Management.   The   ENVIRONMENT   offers
     facilities  for  automatic handling of data; business, statistical or
     custom measures of PERFORMANCE, simple and complex  profit  modeling,
     validation   sample  tests,  advanced  confidence  tests,  real  time
     graphics, and optional control over the internal GA.

     For further information,  contact:  KiQ,  Business  Modeling  Systems
     Ltd.,  Easton  Hall,  Great Easton, Essex CM6 2HD, UK.  Tel: +44 1371
     870254 (Unverified 8/94).

 OOGA:
     OOGA  (Object-Oriented  GA)  is  a  GENETIC  ALGORITHM  designed  for
     industrial  use.   It  includes examples accompanying the tutorial in
     the companion "Handbook of Genetic Algorithms". OOGA is designed such
     that each of the techniques employed by a GA is an object that may be
     modified, displayed or replaced in object-oriented fashion.  OOGA  is
     especially well-suited for individuals wishing to modify the basic GA
     techniques or tailor them to new domains.

     The buyer of OOGA also receives Genesis (see  above).   This  release
     sports  an  improved  user interface.  OOGA and Genesis are available
     together on 3.5''  or  5.25''  disk  for  $60  ($52.50  inside  North
     America)  by  order from: The Software Partnership (T.S.P.), P.O. Box
     991, Melrose, MA 02176, USA.  Tel: +1 617 662 8991 (Unverified 8/94).

 PC-Beagle:
     PC-Beagle  is a rule-finder program for PCs which examines a database
     of examples and uses machine-learning techniques to create a  set  of
     decision rules for classifying those examples, thus turning data into
     knowledge.  The system contains six major components,  one  of  which
     (HERB - the "Heuristic Evolutionary Rule Breeder") uses GA techniques
     to generate rules by natural SELECTION.

     PC-Beagle is available to educational users for 69  pounds  sterling.
     Orders,  payment  or requests for information should be addressed to:
     Richard Forsyth, Pathway Research Ltd., 59 Cranbrook Rd., Bristol BS6
     7BS, UK.  Tel: +44 117 942 8692 (Unverified 8/94).

 XpertRule GenAsys:
     XpertRule  GenAsys  is  an  expert system shell with embedded GENETIC
     ALGORITHM marketed by Attar Software. Targeted  to  solve  scheduling
     and  design  applications,  this system combines the power of genetic
     algorithms  in  evolving  solutions  with  the  power  of  rule-based
     programming  in  analyzing the effectiveness of solutions. Rule-based
     programming can also be used to generate the initial  POPULATION  for
     the  genetic  algorithm  and  for  post-optimization  planning.  Some
     examples of design and scheduling problems which  can  be  solved  by
     this  system include: OPTIMIZATION of design parameters in electronic
     and  avionic  industries,  route  optimization  in  the  distribution
     sector, production scheduling in manufacturing, etc.

     For  further  information,  contact:  Attar  Software, Newlands Road,
     Leigh,     Lancashire,     UK.      Tel:     +44     1942     608844.
     <100116.1547@CompuServe.com> http://www.attar.com (confirmed 3/96).

 XYpe:
     XYpe  (The  GA Engine) is a commercial GA application and development
     package for the Apple Macintosh. Its standard user  interface  allows
     you  to  design CHROMOSOMEs, set attributes of the genetic engine and
     graphically display its progress. The development package provides  a
     set  of  Think C libraries and include files for the design of new GA
     applications. XYpe supports adaptive operator weights and mixtures of
     alpha, binary, gray, ordering and real number codings.

     The  price  of  $725  (in  Massachusetts  add  5% sales tax) plus $15
     shipping  and  handling  includes   technical   support   and   three
     documentation  manuals.   XYpe  requires a Macintosh SE or newer with
     2MB RAM running OS V6.0.4 or  greater,  and  Think  C  if  using  the
     development package.

     Currently  the  GA  engine  is  working;  the  user interface will be
     completed on demand. Interested parties should  contact:  Ed  Swartz,
     Virtual  Image,  Inc.,  75  Sandy Pond Road #11, Ayer, MA 01432, USA.
     Tel: +1 (508) 772-4225 (Unverified 8/94).

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

Subject: Q20.3: Current research projects?

 PAPAGENA:
     The European ESPRIT III project PAPAGENA is pleased to  announce  the
     availability of the following book and software:

     Parallel  Genetic  Algorithms:  Theory  and Applications was recently
     published by IOS press. The book, edited by Joachim Stender, provides
     an  overview  of  the  theoretical,  as  well  as  practical, aspects
     involved  in  the  study  and  implementation  of  parallel   GENETIC
     ALGORITHMs (PGAs).

     The  book comes with a floppy disk version of GAME (Genetic Algorithm
     Manipulation Environment).  For more information see the  section  on
     GAME in Q20.2.

 PeGAsuS:
     PeGAsuS   is  a  general  programming  environment  for  evolutionary
     algorithms.  developed at the German  National  Research  Center  for
     Computer  Science.   Written  in  ANSI-C,  it  runs  on MIMD parallel
     machines, such as transputers, and  distributed  systems, as well  as
     serial machines.

     The   Library   contains GENETIC OPERATORs, a  collection  of FITNESS
     functions, and input/output and control procedures.  It provides  the
     user with  a  number  of validated modules. Currently, PeGAsuS can be
     compiled with the GNU C, RS/6000 C, ACE-C, and  Alliant's  FX/2800  C
     compilers.   It  runs on SUNs and RS/6000 workstations, as well as on
     the Alliant FX/28.  PeGAsuS is not available to the public.

     For more information contact: Dirk Schlierkamp-Voosen, Research Group
     for  Adative  Systems,  German  National Research Center for Computer
     Science, 53731  Sankt  Augustin,  Germany.   Net:  <dirk.schlierkamp-
     voosen@gmd.de>

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

     Copyright  (c) 1993-1996 by J. Heitkoetter and D. Beasley, all rights
     reserved.

     This FAQ may be posted to any USENET newsgroup, on-line  service,  or
     BBS  as  long  as  it  is  posted  in  its entirety and includes this
     copyright statement.  This FAQ may not be distributed  for  financial
     gain.   This  FAQ  may  not  be included in commercial collections or
     compilations without express permission from the author.

End of ai-faq/genetic/part5
***************************

