Q20.1: Free software packages?

     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).

     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

     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 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 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:

 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,born}@fb10.tu-
     berlin.de> (Unverified 8/94).

     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  (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

     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

     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-

     GALOPPS (Genetic Algorithm Optimized for Portability and Parallelism)
     is a flexible, generic GA, based upon SGA-C. It has been extended  to
     provide  three  types of island parallelism, ranging from a single PC
     simulating  parallel  subpopulations,  to  multiple  computers  on  a
     network.   It's  been  tested  on  a  wide  variety  of  DOS and UNIX
     machines.  An 80-page User Guide is provided.

     GALOPPS extends the SGA capabilities several fold:

     o  5 SELECTION methods.

     o  Random or superuniform initialization of binary CHROMOSOMEs.

     o  3 CROSSOVER routines for value-based representations,  and  4  for
	order-based reps.

     o  3 MUTATION routines.

     o  4 FITNESS scaling routines.

     o  Various   replacement   strategy   options,   including   crowding
	replacement and new incest-reduction option.

     o  Elitism is optional.

     o  Convergence: lost, CONVERGED, percent converged, etc.

     o  Various PERFORMANCE measures

     o  Uses "SGA philosophy" of one template file for the user to modify,
	but  enriched  with  many  additional  user  callbacks,  for added
	flexibility, extensibility.

     Ten  sample  applications  are  provided  --  "standard"   ones   are
     Goldberg's  three examples, Holland's Royal Road "Challenge" problem,
     and a blind traveling salesperson problem.

     For portability, the user interface in the standard  distribution  is
     non-graphical.  A number of GUIs are in development.

     GALOPPS  Release  2.20  and manual v2.20.ps are available by FTP from

     Contact: Erik Goodman, Genetic Algorithms Research  and  Applications
     Group  (GARAGe),  Computer Science and Case Center for Computer-Aided
     Engineering and Manufacturing,  112  Engineering  Building,  Michigan
     State University, East Lansing 48824.  <goodman@egr.msu.edu>

     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

     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 and version 2.0 will be
     released in early 1995.

     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

     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 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>

 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.

     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

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

     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

     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

     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 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

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

     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  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

     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 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-

     Author:   Jochen  Ruhland,  FG  Neuronale  Netzwerke  /  Uni  Kassel,
     Heinrich-Plett-Str.      40,      D-34132      Kassel,       Germany.

     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" (Springer Verlag,
     2nd ed, 1994).

     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

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

     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

     Joe Culberson, Department of Computer Science, University of Alberta,
     CA.  Net: <joe@cs.ualberta.ca>

     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:

     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  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

     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:

     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>

     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@wiltel.com> (Unverified

     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

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

     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.

     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

     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

     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

     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:

     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

     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>

 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.

     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  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

     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  (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

     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:

     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.

     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>

     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

     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


     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 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

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

Go To Previous

Go To Next