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

     BUGS  was  written  by  Joshua  Smith <jrs@media.mit.edu> at Williams
     College           and           is           available           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 the download section under
     http://www.bitstar.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  ftp://lamport.rhon.itam.mx/  and  from
     ftp.aic.nrl.navy.mil/pub/galist/src/ga/dgenesis-1.0.tar.Z

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

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

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

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

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

 Ease:
     Ease   -  Evolutionary  Algorithms  Scripting  Environment  -  is  an
     extension to  the  Tcl  scripting  language,  providing  commands  to
     create,  modify,  and evaluate POPULATIONs of INDIVIDUALs represented
     by real number vectors and/or bit strings. With Ease, a  standard  ES
     or GA can be written in less than 20 lines of code.

     Ease  is available as source code for Linux and Solaris under the GNU
     Public License. Tcl version 8.0 or higher is required.  If  you  know
     how generate DLLs, you may be able to use it on Win9x/NT, as well.

     The URL is http://www.sprave.com/Ease/Ease.html .  Written by Joachim
     Sprave <sprave@LS11.cs.uni-dortmund.de>.

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

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

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

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

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

     The EM includes extensive menu techniques with:

     o  Default parameter setting for unexperienced users.

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

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

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

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

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

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

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

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

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

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

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

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

 GAGS:
     GAGS (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 <mbwall@mit.edu>

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

     User may choose:

     o  problem type (permutation or value-type)

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

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

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

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

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

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

     GALOPPS allows and supports:

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

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

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

     o  mate selection, using incest reduction

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

     o  optional ELITISM

     Generic  (Unix)  GALOPPS 3.2 (includes 80-pp. manual) is available on
     ENCORE.   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,  <goodman@egr.msu.edu>,  MSU  GARAGe,  Case
     Center, 112 Engineering Building, MSU, East Lansing, MI 48824 USA.

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

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

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

 GANNET:
     GANNET  (Genetic  Algorithm  /  Neural NETwork) is a software package
     written by Jason Spofford in 1990 which allows one to  evolve  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://www.duane.com/~dduane/gannet
      .  As  well  as  the software, the masters thesis that utilized this
     program as well as a paper is available in this directory.

     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:
     <majordomo@duane.com> On the first  line  of  the  message  (not  the
     subject) type: subscribe gannet

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

 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
     ftp.cs.ucsd.edu/pub/GAucsd/GAucsd14.sh.Z           or            from
     ftp.aic.nrl.navy.mil/pub/galist/src/GAucsd14.sh.Z  To  be  added to a
     mailing list for bug reports, patches and updates, send "add  GAucsd"
     to <listserv@cs.ucsd.edu>.

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

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

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

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

 Genesis:
     Genesis is a generational GA system written in C by John Grefenstette
     <gref@aic.nrl.navy.mil>.  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:    <baeck@ls11.informatik.uni-
     dortmund.de> (Unverified 8/94).

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

     Also, the paper "Mutation-Crossover Isomorphisms and the Construction
     of  Discriminating  Functions"  gives  a  more  in-depth  look at the
     behavior      of      GIGA.      Its      is      available      from
     ftp.cs.ualberta.ca/pub/joe/Preprints/xoveriso.ps.Z

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

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

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

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

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

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

     Imogene  is  based  on  work  originally  done  by   Karl   Sims   at
     (ex-)Thinking Machines for the CM-2 massively parallel computer - but
     you  can  use  it  on  your   PC.   You   can   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  <davis@ilog.fr>

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

     Four sample problems are contained in the code: three with bit  GENEs
     and  one  with  double  genes.  To use this program, modify the class
     MyChromosome to include your problem, which you have  coded  in  some
     class,  say  YourChromosome.  All changes to the sGA.java file to run
     your problem are confined to your class YourChromosome.  This is what
     object-oriented  programming  is all about!  The sGA.java source code
     file has a big comment at the end containing some sample runs.

     Available by FTP from ftp.mcs.drexel.edu/pub/shartley/simpleGA.tar.gz
     .      Further     information     from     Stephen     J.    Hartley
     <shartley@mcs.drexel.edu>,   http://www.mcs.drexel.edu/~shartley    .
     Drexel University, Math and Computer Science Department Philadelphia,
     PA 19104 USA. +1-215-895-2678

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

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

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

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

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

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

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

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

     Contact: Dave Goldberg <goldberg@vmd.cso.uiuc.edu>

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

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

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

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

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

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

     o  maximize the number of bits set in a CHROMOSOME
     o  De Jong's functions DJ1, DJ2, DJ3, DJ5

     o  binary F6, used by Schaffer et al

     o  a  crude  1-d  knapsack problem; you specify a target and a set of
	numbers in an external file, GA tries to find a subset  that  sums
	as closely as possible to the target
     o  the `royal road' function(s); a chromosome is regarded as a set of
	consecutive blocks of size K, and scores K for each block entirely
	filled with 1s, etc; a range of parameters.

     o  max contiguous bits, you choose the ALLELE range.

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

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

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

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

     PGA  has  been  used  for teaching for a couple of years now, and has
     been used as a starting point by a fair number of  people  for  their
     own projects. So it's reasonably reliable. However, if you find bugs,
     or have useful contributions to make, Tell Me! It is available by FTP
     from ftp.dai.ed.ac.uk/pub/pga/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: <peter@aisb.ed.ac.uk>

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

     Features include:

     o  Callable from Fortran or C.

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

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

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

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

     o  Multiple levels of access for expert users.

     o  Extensive debugging facilities.

     o  Large set of example problems.

     o  Detailed users guide

     o  Parameterized POPULATION replacement.
     o  Multiple choices for SELECTION, CROSSOVER, and MUTATION operators

     o  Easy integration of hill-climbing heuristics.

     Availability:  PGAPack is freely available and may be obtained by FTP
     from     info.mcs.anl.gov/pub/pgapack/pgapack.tar.Z      or      from
     http://www.mcs.anl.gov/pgapack.html
     Further  Information  from  David  Levine,  Mathematics  and Computer
     Science Division,  Argonne  National  Laboratory,  Argonne,  Illinois
     60439,               (708)-252-6735              <levine@mcs.anl.gov>
     http://www.mcs.anl.gov/home/levine

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

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

     See also:

      Neri  F.  and Giordana A. (1995). "A Distributed  Genetic  Algorithm
     for  Concept  Learning",  Proc.  Int.   Conf.   on Genetic Algorithms
     (Pittsburgh, PA), Morgan Kaufmann, pp. 436-443.

      Neri  F.  and  Saitta L. (1995). "A Formal  Analysis  of
      Selection  Schemes".  Proc.   Int.   Conf.   on  Genetic  Algorithms
     (Pittsburgh,PA), Morgan Kaufmann, pp. 32-39 .

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

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

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

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

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

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

     SGA-C and SGA-Cube are also available in compressed tar form  by  FTP
     from   ftp.aic.nrl.navy.mil/pub/galist/src/ga/sga-c.tar.Z   and  sga-
     cube.tar.Z .
 Splicer:
     Splicer  is  a  GENETIC  ALGORITHM  tool  created  by  the   Software
     Technology  Branch  (STB)  of  the Information Systems Directorate at
     NASA/Johnson Space Center with support from  the  MITRE  Corporation.
     Splicer   has   well-defined   interfaces   between   a   GA  kernel,
     representation  libraries,  FITNESS  modules,  and   user   interface
     libraries.

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

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

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

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

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

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

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

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

 Trans-Dimensional Learning:
     This  is  a  Windows  3.1  artificial  neural  netwrk  and GA program
     (shareware).  TDL 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: <upso@prodigy.com>

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

     This   program   used   to   be   available   free   by   FTP    from
     riacs.edu/pub/wolf-4.0.tar.Z  (However  this machine no longer allows
     anonymous ftp access, so you wont be able to get it  from  there  any
     more.  If  anyone  knows anywhere this code is freely available from,
     let us know. Ed.)  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> (Note - this address may be

 XGenetic:
     XGenetic is an ActiveX control for the implementation  of  a  GENETIC
     ALGORITHM  in  any  language  that  accepts ActiveX interfaces.  Such
     languages include, but are not limited to: Visual Basic, Visual  C++,
     Delphi,  etc.   Written  in Visual Basic 6.0, XGenetic is flexible in
     implementation to allow the user to easily define the parameters  for
     their  particular  scenario,  be  it  forecasting, scheduling, or the
     myriad of other uses for the genetic algorithm.

     Features:  ( ** indicates registered version only)

     o  Data Types: Bit, Integer, Real

     o  Selection Operators: Roulette, Tournament **, Stochastic Universal
	Sampling **, Truncation **, Random **

     o  Crossover  Operators:  N-Point  (1  point, 2 point, 3 point, etc),
	Uniform **, Arithmetic **

     o  Mutation Operators: Uniform, Boundary **

     There are two versions of  the  software  available.   The  shareware
     version  of  the  product  is  available  freely  off the net(address
     below).     It    includes    the    program    file(xgen.ocx)    and
     documentation(including  a  sample  program)  in  three formats.  The
     registered version is  available  from  the  author  directly  for  a
     registration  fee of $50.  Commercial licences may be negotiated with
     the  author.   The  shareware  version  may   be   downloaded   from:
     http://www.winsite.com/info/pc/win95/demo/xgen-sw.zip

     For  further  information, contact the author, Jeff Goslin, by email:
     <autockr@ix.netcom.com>, or by snail-mail: 27842 Flanders Ave, Warren
     MI 48093, USA.

 CLASSIFIER SYSTEMS
 CFS-C:
     CFS-C  1.0  is  a  domain independent collection of CLASSIFIER SYSTEM
     routines written by Rick L. Riolo <rlr@merit.edu> 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
     <engel@asterix.irb.uni-hannover.de> is also available. This  includes
     bug fixes of earlier versions, allowing it to run on a wider range of
     machines (e.g. Linux and nCUBE). It also has an XView front end  that
     makes  it  easier  to control, and some extensions to the algorithms.
     It is available from Encore in file:  CFS/src/cfscxv-0.1.tar.gz  with
     documentation in CFS/docs/cfscxv-0.1.readme.gz

     References

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

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

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

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

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

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

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