release-notes

麻省理工开发的免费遗传算法类库GAlib,很好用

An implementation of the edge recombination crossover (ERX) for list genomes 
is included in two of the examples (for the travelling salesman problems). 

A new revision, Revision B, of the PostScript documentation. 

Fixed a problem in the statistics object that caused it to record the wrong 
scores when minimizing the objective. 

Fixed the scaling, statistics, and population objects to handle large 
objective scores properly (scores that are near FLT_MAX and/or FLT_MIN). 

Major cleanup of the MacOS and DOS/Windows versions of GAlib. Installation is 
an order of magnitude easier. 

Added a graphic travelling salesman example (graphic examples are only 
available for unix versions - Mac and PC versions will come as soon as I have 
the basic code to do graphic display and rudimentary GUI on those platforms). 

Fixed the simple genetic algorithm class to do elitism properly when 
minimizing. 

Added virtual destructors to the Node and NodeBASE classes so that derived 
node classes will work properly. 

Fixed the formating problems in the DOS/Windows package, including both the 
end-of-line characters and the GIF images. 




Changes in version 2.4
released 3 June 1996
-------------------------------------------------------------------------------
The base genetic algorithm class, 'GA', was renamed to 'GAGeneticAlgorithm' 

Function prototypes for genome operators are now defined in the genome scope. 
Similarly, function prototypes for genetic algorithm and population object 
operators are defined in their respective scopes. 

The 'score' member of the genome can now be used on const genomes. 

The documentation is now distributed with GAlib. The documentation now 
contains a page illustrating how to define your own operators and derive your 
own GAlib-based classes. 

GAlib now compiles warning-free when you use the -Wall flag for the g++ 
compiler. The number of warnings when compiled with Borland, Metrowerks, and 
Symantec compilers has also been reduced (although Borland still won't let 
you inline for, while, or switch statements). 

The config.h header file now figures out as much as possible about your 
system so that you should not have to tweak it nearly as much as in previous 
releases. 
GASUSSelector was renamed to GAUniformSelector 

The GASharing object has been reworked to better match the description of 
scaling proposed by Goldberg. It now lets you select both the sigma cutoff 
and alpha values for tuning the scaling radius and importance. 

The steady-state genetic algorithm will now work properly with the sharing 
method of fitness scaling (although Goldberg typically refers to sharing in 
the context of non-overlapping populations, you can use it with overlapping 
populations if you do the replacement right). 

GAlib works with PVM 3.3.10 or later. This release of GAlib includes examples 
that show how to use GAlib with PVM for two types of parallelization: (1) one 
genome per process/CPU and (2) one population per process/CPU. I'm also 
considering an MPI example (if only there were stable C++ bindings for PVM 
and MPI). 

Parallel populations on a single CPU are now possible using the island model 
with migration rates and (custom) replacement between populations. Each 
population can have its own selection and replacement methods, independent of
 the other populations. By default all populations are clones of each other 
(same initialization, mutation, crossover, selection, replacement). The 
parallel populations are evolved using steady-state genetic algorithm model 
with user-specified overlap, etc. This is illustrated in one of the examples. 

Default and built-in operators are now defined as static member function of 
the genome classes with which they are associated. This cleans up the 
namespace quite a bit. 

Template classes now have default operators whereever they can be defined - 
no more ARRAY_TYPE or LIST_TYPE. 

The genome files have been consolidated. Rather than a bunch of files 
(typically 6) for each genome, the library uses a single pair (.h and .C) for 
each genome. For example, binstr1.[ch|xs|op].[C|h] is now simply 
binstr1.[C|h]. 

Genomes now contain an 'evaluation data' object. This is a pointer to an 
object derived from the EvalData class. Its purpose is to provide a mechanism 
for storing custom information with each genome. The userData member is 
similar in function, but whereas the userData object is the same for all 
genomes, the evalData object may be different for each genome. (the evalData 
object supercedes the 'ObjectiveVector') 

The ArrayGenome class has been restructured as ArrayGenome and 
ArrayAlleleGenome (derived from ArrayGenome). The library includes 
instantiations of char and double versions of the ArrayAlleleGenome class to 
form the StringGenome and RealGenome classes. The RealGenome class provides a 
mechanism for doing an array of bounded real numbers and/or sets of real 
numbers. Sample uniform and gaussian mutator are included for the RealGenome 
class. 

A new compile-time flag, NO_STREAMS, has been added to let you
compile-out the GAlib dependencies on the streams library. When you
compile-out the streams dependencies you cannot use the default GAlib
routines for reading from and writing to file, but the error routines
will still work properly.  

Error handling has been improved a little sages to a GAlib-specific
error handler. You can override the library's error handler to
redirect (or ignore) the messages as you see fit.  

A converter architecture has been added to the binary string
objects. GAlib contains two default converters: Gray and 

Binary encode/decode. You can use either of these or define your own
for mapping decimal values into the binary strings. The
binary-to-decimal conversions now support more bits - up to 128
(depending on the system you're running on).  

The statistics object has been cleaned up and more statistics have
been added. GAs can now flush stats periodically to file or on-demand,
and the types of stats that get recorded can be controlled. The
interface for recording scores, score buffering, and flushing to file
has been revamped.  

The parameters object has been completely overhauled. It can now read
from the command line and/or a settings file using (user definable)
strings to set the GA parameters. Since each GA contains a parameters
object, these capabilities have also been extended to the GA classes.  

The base genome class has been cleaned up. In particular, the clone
method and dimension enums have been declared in the genome scope to
reduce namespace clutter. Also changed are the read/write member
functions. They have been renamed (no underscore) and return an
integer status. The crossover interface is completely different (see
below). 

Now each genome contains a crossover hint that suggests to a GA how it
should mate. By default, the GAs use this information to do the
crossovers, but a custom GA can ignore the suggested crossover and do
its own mating if it wants to. The equal/not equal members are now
public and the underscore has been removed.  

A compare member function has been added to the genome class. This
member function (customizable) provides a mechanism for measuring the
diversity of a population.  

The CrossSite object no longer exists. A new member function,
'crossover', and two access functions, 'sexual' and 'asexual', have
taken its place. The crossover function operates on one or two
children, so the site information is no longer stored with each
genome. The new interface also defines a mechanism for doing asexual
reproduction, so it is easier now to implement GAs that use this kind
of mating. You can also define crossovers that operate on genomes with
mixed data types (this will require a special GA, but you can derive
that from one of the standard GA objects then modify the crossover
part).  

The allele set now does reference counting. This allows you to define
an allele set in a scope other than the scope in which the genome(s)
is defined. It also reduces overhead - each genome does not need to
keep its own copy of the allele set.  

Binary-to-decimal phenotypes now do reference counting. Like the
allele sets, phenotypes are needed by many genomes. But there's too
much overhead to require each genome to keep its own copy of the
phenotype. So now you can create a single phenotype (for your
prototype genome) and subsequent clones of your genome will refer to
the same phenotype, even if it goes out of scope.  

A new object, BoundsSet, has been defined to work with the bounded
array genome types. It behaves much like an allele set.  

The constants for tree and list return codes have been rolled into
their respective objects to reduce namespace clutter.  

Genome comparators now return 0 for identical genomes and greater than
0 for completely different genomes. This makes better lexical sense:
as the diversity decreases, so does the absolute measure. Notice that
previous versions of GAlib expected the opposite measure.  

I made a number of changes to typedef names to make things more
consistent. These changes include:   
        'GAInitializationOperator' is now 'GAGenome::Initializer' 
        'GAMutationOperator' is now 'GAGenome::Mutator' 
        'GADistanceFunction' is now 'GAGenome::Comparator' 

Changed name of 'GAReplacementGA' to 'GAIncrementalGA'. The
functionality of this genetic algorithm type has not changed.  

Changed the name of 'types.h' to 'gatypes.h' to avoid conflicts with
the system types.h file on many platforms.  

The selection function is now a member of the population object. The
signature has not changed, and the selection function is still
custimizable, but now housekeeping of population statistics is much
more uniform and less convoluted. This also allows you to define a
different selection method for each of the populations when using
multiple populations.  

Fixed the bug in the population copy method. The bug caused the
population to clone the worst individual multiple times rather than
cloning each individual in the population. The patch is descibed in
the bugs page.  

Changing the population size during an evolution now works without the
extra call to evaluate. Fixed the bug in the scaling object that
prevented the updates after initialization. The patch is descibed in
the bugs page.  

Lots of minor const-correctness tweaks and cleanup of the code, plus
fixes of all reported bugs. The new version is marginally faster than
the previous.  

Older versions of the library had problems when objects used by other
objects went out of scope. For example, if you created a genome using
an allele set then left the scope in which the allele set was active,
the genome would refer to garbage. These inconsistencies have been
fixed. Objects now make copies of the objects they need, but make no
more copies than necessary. There's a whole lot of reference counting
and caching going on now.