author: David Beasley

subject: FAQ: comp.ai.genetic part 5/6 (A Guide to Frequently Asked Questions)

text:
Archive-name:   ai-faq/genetic/part5
Last-Modified:  9/30/98
Issue:          6.3

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
     <[email]>.

     A  survey paper entitled "Genetic Algorithm Programming Environments"
     was published in IEEE Computer in the June 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
     (file size: 421k).

 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             <[email]>

      Computer-   ED, Win     ?      free   Scott Kennedy, Axcelis Inc.
      Ants        GA                       <[email]>

      DGenesis    GE, Unix    C      free   Erick Cantu-Paz
		 PA,ED                     <[email]>

      DOUGAL      SS, DOS     Turbo  free   Brett Parker
		  GE          Pascal       <[email]>

      ESCaPaDE    ES  Unix    C      free   Frank Hoffmeister
				<[email]>

      Evolution   GE, DOS     C      free   Hans-Michael Voigt and
      Machine     ES                        Joachim Born
					   <[email]>

      Evolutionary GE,  Unix  C++    free   JJ Merelo
      Objects      OO                      <[email]>

      GAC,        GE  Unix    C      free   Bill Spears
      GAL         "   "       Lisp   "     <[email]>

      GAGA        GE  Unix    C      free   Jon Crowcroft
					   <[email]>

      GAGS        GE, Unix,   C++    free   JJ Merelo
	       SS,OO  DOS                  <[email]>

      GAlib       GA  Unix,   C++    free   Matthew Wall
		      Mac,DOS              <[email]>

      GALOPPS     GE, Unix,   C      free   Erik Goodman
		  PA  DOS                  <[email]>

      GAMusic     ED  Win    (VB)    $10   Jason H. Moore
					   <[email]>

      GANNET      GE, Unix    C      free   Darrell Duane
		  NN                       <[email]>

      GAucsd      GE  Unix    C      free   Nici Schraudolph
					   <[email]>

      GA          GE, DOS     (C++)  free   Mark Hughes
      Workbench   ED                       <[email]>

      GECO        GE, Unix,   Lisp   free   George P. W. Williams, Jr.
		OO,ED MacOS                <[email]>

      Genesis     GE, Unix,   C      free   John Grefenstette
		  ED  DOS                  <[email]>

      GENEsYs     GE  Unix    C      free   Thomas Baeck
				      <[email]>

      GenET       SS, Unix,   C      free   Cezary Z. Janikow
		ES,ED X, etc.              <[email]>

      Genie       GE  Mac     Think  free   Lance Chambers
			      Pascal       <[email]>

      Genitor     SS  Unix    C      free   Darrell Whitley
					   <[email]>

      GENlib      SS  Unix,   C      (6)    Jochen Ruhland
		      DOS            <[email]>

      GENOCOP     GE  Unix    C      free   Zbigniew Michalewicz
					   <[email]>

      GIGA        SS  Unix    C      free   Joe Culberson
					   <[email]>

      GPEIST      GP  Win,   Small-  free   Tony White
		      OS/2   talk          <[email]>

      Imogene     GP  Win     C++    free   Harley Davis
					   <[email]>

      JAG         GA  -      Java   free   Stephen Hartley
					   <[email]>

      LibGA       GE, Unix/DOS C     free   Art Corcoran
	       SS,ED  NeXT/Amiga           <[email]>

      LICE        ES  Unix,   C      free   Joachim Sprave
		      DOS                  <[email]>

      Matlab-GA   GE  ?       Matlab free   Andy Potvin
					   <[email]>

      mGA         GE  Unix    C,     free   Dave Goldberg
			      Lisp         <[email]>

      PARAGenesis PA, CM      C*     free   Michael van Lent
		  GE                       <[email]>

      PGA         PA, Unix,   C      free   Peter Ross
		SS,GE etc.                 <[email]>

      PGAPack     GA, any     C      free   David Levine
		  PA                       <[email]>

      REGAL       GA          C      free   Filippo Neri
					   <[email]>

      SGA-C,      GE  Unix    C      free   Robert E. Smith
      SGA-Cube        nCube                <[email]>

      Splicer     GE  Mac,    C      (1)    Steve Bayer
		      X11

      TOLKIEN     OO, Unix,   C++    free   Anthony Yiu-Cheung Tang
		  GE  DOS                  <[email]>

      Trans-Dimensional
      Learning    NN  Win     ?      free  <[email]>

      WOLF        SS  Unix    C      free   David Rogers
					   <[email]>
     =========================================================================

		  Classifier System Implementations:

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

      CFS-C     CF,  Unix/DOS  C    free   Rick Riolo
		ED                        <[email]>

      SCS-C     CF,  Unix/DOS  C    free   Joerg Heitkoetter
		ED   Atari TOS            <[email]>
     ==========================================================================

		     Commercial Packages:

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

      ActiveGA  GA   Win   (ActiveX) $99    Brightwater Software
					   <[email]>

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

      EvoFrame/ OO,  Mac,     C++/   (4,2)  Optimum Software
      REALizer  ES   DOS      OPas   (5,2) <[email]>

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

      FlexTool  GA   Win      Matlab ?      Flexible Intelligence Group
					   <[email]>

      GAME      OO,  X11      C++     (3)   Jose R. Filho
		GA                         <[email]>

      GeneHunter GA  Win,    (VB)    $369   Ward Systems
		     Excel                 <[email]>

      Generator GE,SS Win,   (C++)   $379   Steve McGrew, New Light Industries
	     ES,OO,ED Excel                <[email]>

      MicroGA/  OO,  Mac,     C++    $249   Emergent Behavior, Inc.
      Galapagos SS   Win              (2)  <[email]>

      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)       <[email]>

      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  <[email]>  at  Williams
     College           and           is           available           from
     www.aic.nrl.navy.mil/pub/galist/src/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   <[email]>   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. <[email]>

 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:
     <[email]>

 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:   <[email]-
     berlin.de>, <[email]> (Unverified 8/94).

 EVOLUTIONARY OBJECTS:
     EO  (Evolutionary  Objects)  is a C++ library written and designed to
     allow a variety of evolutionary algorithms to be constructed  easily.
     It is intended to be an "Open source" effort to create the definitive
     EC library.  It  has:  a  mailing  list,  anon-CVS  access,  frequent
     snapshots and other features.  For details, see http://fast.to/EO

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

 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
     <[email]>. A windows version is in preparation.

 GAC, GAL:
     Bill Spears <[email]> 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  <[email]>,  Univeristy College
     London,  Gower  Street,  London  WCIE  6BT,  UK,  or  by   FTP   from
     ftp://cs.ucl.ac.uk/darpa/gaga.shar

 GAGS:
     GAGS  (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   from:
     http://kal-el.ugr.es/GAGS  The  programmer's  manual  is  in the file
     gagsprogs.ps.gz.  GAGS is also available from ENCORE (see  Q15.3)  in
     file  EC/GA/src/gags-0.92.tar.gz (there may be a more recent version)
     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 <[email]>

 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.   For  PVM  GALOPPS,  PC  version  (different  line  endings,
     makefiles), Threaded  GALOPPS,  and  GALOPPS-based  2-level  adaptive
     system, see the MSU GARAGe web site: http://GARAGe.cps.msu.edu/ .

     Contact:  Erik  D.  Goodman,  <[email]>, 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   <[email]>   or
     <[email]>

 GANNET:
     GANNET (Genetic Algorithm / Neural NETwork)  is  a  software  package
     written  by  Jason Spofford in 1990 which allows one to evolve binary
     valued 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 neurons
     in a net. Research using GANNET is continuing.

     GANNET 2.0 is available at http://fame.gmu.edu/~dduane/thesis
      . As well as the software, the masters  thesis  that  utilized  this
     program  as well as a paper is available in this directory.  See also
     fame.gmu.edu/gannet/source/

     The major enhancement of version 2.0  is  the  ability  to  recognize
     variable length binary strings, such as those that would be generated
     by  a  finite  automaton.   Included  is  code  for  calculating  the
     Effective Measure Complexity (EMC) of finite automata as well as code
     for generating test data.

     A mailing list has been established for discussing uses and  problems
     with   the  GANNET  software.   To  subscribe,  send  a  message  to:
     <[email]> On the first line of the message (not the subject)
     type: SUB GANNET Your-First-Name Your-Last-Name

     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:
     <[email]> or <[email]>

 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 <[email]>.

     Cognitive Computer Science Research Group, CSE Department, UCSD 0114,
     La Jolla, CA 92093-0114, USA.  Net: <[email]>

 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: <[email]>.

 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/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:   <[email]-
     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: <[email]>

 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: <[email]> 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
     <[email]>.  If these  fail  to  work,  contact:  L.
     Darrell   Whitley,   Dept.   of   Computer  Science,  Colorado  State
     University,    Fort     Collins,     CO     80523,     USA.      Net:
     <[email]> (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.
     <[email]>

 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: <[email]>

 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: <[email]>

 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 <[email]>

 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  get  Imogene  from:
     http://www.aracnet.com/~wwir/software.html

     Contact: Harley Davis, ILOG S.A., 2  Avenue  Gallini,  BP  85,  94253
     Gentilly Cedex, France. tel: +33 1 46 63 66 66  <[email]>
 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 ftp.mcs.drexel.edu/pub/shartley/simpleGA.tar.gz
     .     Further     information     from     Stephen     J.     Hartley
     <[email]>,    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 <[email]>
     (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 <[email]>

 Matlab-GA:
     The MathWorks FTP site has some  Matlab  GA  code  in  the  directory
     ftp.mathworks.com/pub/contrib/v4/optim/genetic  It's  a  bunch  of .m
     files  that  implement  a  basic   GA.    Contact:   Andrew   Potvin,
     <[email]> 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:
     <[email]>.

 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/pga-3.1.tar.gz (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: <[email]>

 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               <[email]>
     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
     <[email]>  http://www.di.unito.it/~attilio/  and  Filippo
     Neri   <[email]>   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: <[email]>

     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  <[email]> (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 <[email]>,  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  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 on the WWW from: http://pages.prodigy.com/upso

     For further details contact: <[email]>

 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: <[email]>

 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 its
     "cfsc/orig"  folder  after  unpacking.  On  the "SyS" FTP server its:
     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
     <[email]> 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 <[email]>.

     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: <[email]>.

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

Subject: Q20.2: Commercial software packages?

 ActiveGA:
     ActiveGA is an activeX (OLE) control that uses a GENETIC ALGORITHM to
     find a solution for a given problem. For example, you can  insert  an
     ActiveGA  control  into  Microsoft Excel 97 and have it optimize your
     worksheet.

     Features include:

     o  OPTIMIZATION Mode: Minimize, Maximize or Closest To

	o SELECTION Mode: Tournament, Roulette Wheel

	o User defined POPULATION size, MUTATION rate and other parameters

	o Event driven, cancelable iteration

	o Invisible at run time

	o Excel 97, Visual Basic, Visual C++ samples

     Various  samples  are  available  for  free  download.  For these and
     further                       information,                        see
     http://www.brightsoft.com/products/activega.htm       or      contact
     Brightwater Software <[email]>.  For  a  limited  time
     the  ActiveGA  costs  $99  per  developer.  ActiveGA  has no run time
     royalties.

 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: <[email]>

 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 <[email]> 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: <[email]> (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 <[email]>

 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:   <[email]>   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:
     <[email]>

     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.
     <[email]> 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-
     [email]>

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

     Copyright  (c) 1993-1997 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
***************************