| |
Next
Previous
Contents
Evolutionary computing is actually a broad term for a vast
array of programming techniques, including genetic algorithms,
complex adaptive systems, evolutionary programming, etc.
The main thrust of all these techniques is the idea of
evolution. The idea that a program can be written that will
evolve toward a certain goal. This goal can be
anything from solving some engineering problem to winning a
game.
These are libraries of code or classes for use in programming within
the evolutionary computation field. They are not meant as stand alone
applications, but rather as tools for building your own applications.
- daga
daga is an experimental release of a 2-level genetic algorithm
compatible with the GALOPPS GA software. It is a meta-GA which
dynamically evolves a population of GAs to solve a problem presented to
the lower-level GAs. When multiple GAs (with different operators,
parameter settings, etc.) are simultaneously applied to the same
problem, the ones showing better performance have a higher probability
of surviving and "breeding" to the next macro-generation (i.e.,
spawning new "daughter"-GAs with characteristics inherited from the
parental GA or GAs. In this way, we try to encourage good
problem-solving strategies to spread to the whole population of GAs.
- Ease
Ease - Evolutionary Algorithms Scripting Evironment - 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.
- EO
EO is a templates-based, ANSI-C++ compliant evolutionary
computation library. It contains classes for any kind of
evolutionary computation (specially genetic algorithms) you might
come up to. It is component-based, so that if you don't find the
class you need in it, it is very easy to subclass existing
abstract or concrete class.
- FORTRAN GA
This program is a FORTRAN version of a genetic algorithm driver.
This code initializes a random sample of individuals with
different parameters to be optimized using the genetic algorithm
approach, i.e. evolution via survival of the fittest. The
selection scheme used is tournament selection with a shuffling
technique for choosing random pairs for mating. The routine
includes binary coding for the individuals, jump mutation, creep
mutation, and the option for single-point or uniform crossover.
Niching (sharing) and an option for the number of children per
pair of parents has been added. More recently, an option for
the use of a micro-GA has been added.
- GAGS
Genetic Algorithm application generator and class library
written mainly in C++.
As a class library, and among other thing, GAGS includes:
- A chromosome hierarchy with variable length
chromosomes. Genetic operators: 2-point crossover,
uniform crossover, bit-flip mutation, transposition (gene
interchange between 2 parts of the chromosome), and
variable-length operators: duplication, elimination, and
random addition.
- Population level operators include steady state, roulette
wheel and tournament selection.
- Gnuplot wrapper: turns gnuplot into a
iostreams-like class.
- Easy sample file loading and configuration file parsing.
As an application generator (written in PERL),
you only need to supply it with an ANSI-C or C++ fitness
function, and it creates a C++ program that uses the above
library to 90% capacity, compiles it, and runs it, saving
results and presenting fitness thru gnuplot.
- GAlib: Matthew's Genetic Algorithms Library
GAlib contains a set of C++ genetic algorithm objects. The
library includes tools for using genetic algorithms to do
optimization in any C++ program using any representation and genetic
operators. The documentation includes an extensive overview of how
to implement a genetic algorithm as well as examples illustrating
customizations to the GAlib classes.
- GALOPPS
GALOPPS is a flexible, generic GA, in 'C'. It was based upon
Goldberg's Simple Genetic Algorithm (SGA) architecture, in order to
make it easier for users to learn to use and extend.
GALOPPS extends the SGA capabilities several fold:
- (optional) A new Graphical User Interface, based on TCL/TK,
for Unix users, allowing easy running of GALOPPS 3.2 (single
or multiple subpopulations) on one or more processors. GUI
writes/reads "standard" GALOPPS input and master files, and
displays graphical output (during or after run) of
user-selected variables.
- 5 selection methods: roulette wheel, stochastic remainder
sampling, tournament selection, stochastic universal sampling,
linear-ranking-then-SUS.
- Random or superuniform initialization of "ordinary"
(non-permutation) binary or non-binary chromosomes; random
initialization of permutation-based chromosomes; or
user-supplied initialization of arbitrary types of chromosomes.
- Binary or non-binary alphabetic fields on value-based
chromosomes, including different user-definable field sizes.
- 3 crossovers for value-based representations: 1-pt, 2-pt, and
uniform, all of which operate at field boundaries if a
non-binary alphabet is used.
- 4 crossovers for order-based reps: PMX, order-based, uniform
order-based, and cycle.
- 4 mutations: fast bitwise, multiple-field, swap and random
sublist scramble.
- Fitness scaling: linear scaling, Boltzmann scaling, sigma
truncation, window scaling, ranking.
- Plus a whole lot more....
- GAS
GAS means "Genetic Algorithms Stuff".
GAS is freeware.
Purpose of GAS is to explore and exploit artificial evolutions.
Primary implementation language of GAS is Python. The GAS
software package is meant to be a Python framework for applying
genetic algorithms. It contains an example application where it
is tried to breed Python program strings. This special problem
falls into the category of Genetic Programming (GP), and/or
Automatic Programming. Nevertheless, GAS tries to be useful for
other applications of Genetic Algorithms as well.
- GECO
GECO (Genetic Evolution through Combination of Objects), an
extendible object-oriented tool-box for constructing genetic algorithms
(in Lisp). It provides a set of extensible classes and methods
designed for generality. Some simple examples are also provided to
illustrate the intended use.
- GPdata
GPdata-3.0.tar.gz (C++) contains a version of Andy Singleton's
GP-Quick version 2.1 which has been extensively altered to support:
- Indexed memory operation (cf. teller)
- multi tree programs
- Adfs
- parameter changes without recompilation
- populations partitioned into demes
- (A version of) pareto fitness
This ftp site also contains a small C++ program (ntrees.cc) to
calculate the number of different there are of a given length and
given function and terminal set.
- gpjpp Genetic Programming in Java
- [Dead Link] Web site:
http://www.turbopower.com/~kimk/gpjpp.asp
- Anyone who knows where to find gpjpp, please let me know.
gpjpp is a Java package I wrote for doing research in genetic
programming. It is a port of the gpc++ kernel written by Adam
Fraser and Thomas Weinbrenner. Included in the package are
four of Koza's standard examples: the artificial ant, the
hopping lawnmower, symbolic regression, and the boolean
multiplexer. Here is a partial list of its features:
- graphic output of expression trees
- efficient diversity checking
- Koza's greedy over-selection option for large populations
- extensible GPRun class that encapsulates most details of a
genetic programming test
- more robust and efficient streaming code, with automatic
checkpoint and restart built into the GPRun class
- an explicit complexity limit that can be set on each GP
- additional configuration variables to allow more testing
without recompilation
- support for automatically defined functions (ADFs)
- tournament and fitness proportionate selection
- demetic grouping
- optional steady state population
- subtree crossover
- swap and shrink mutation
- GP Kernel
The GP kernel is a C++ class library that can be used to apply
genetic programming techniques to all kinds of problems. The
library defines a class hierarchy. An integral component is the
ability to produce automatically defined functions as found in
Koza's "Genetic Programming II". Technical documentation
(postscript format) is included. There is also a short
introduction into genetic programming.
Functionality includes; Automatically defined functions (ADFs),
tournament and fitness proportionate selection, demetic grouping,
optional steady state genetic programming kernel, subtree crossover,
swap and shrink mutation, a way of changing every parameter of the
system without recompilation, capacity for multiple populations,
loading and saving of populations and genetic programs, standard
random number generator, internal parameter checks.
- jaga
Simple genetic algorithm package written in Java.
- lil-gp
- patched lil-gp *
lil-gp is a generic 'C' genetic programming tool. It was written
with a number of goals in mind: speed, ease of use and support for a
number of options including:
- Generic 'C' program that runs on UNIX workstations
- Support for multiple population experiments, using
arbitrary and user settable topologies for exchange, for
a single processor (i.e., you can do multiple population gp
experiments on your PC).
- lil-gp manipulates trees of function pointers which are
allocated in single, large memory blocks for speed and to
avoid swapping.
* The patched lil-gp kernel is strongly-typed, with modifications on
multithreading, coevolution, and other tweaks and features.
- Lithos
Lithos is a stack based evolutionary computation system. Unlike most EC
systems, its representation language is computationally complete, while
also being faster and more compact than the S-expressions used in
genetic programming. The version presented here applies the system to
the game of Go, but can be changed to other problems by simply plugging
in a different evaluation function. ANSI C source code is provided.
- PGAPack
Parallel Genetic Algorithm Library
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. Key features are in PGAPack V1.0 include:
- Callable from Fortran or C.
- Runs on uniprocessors, parallel computers, and workstation networks.
- Binary-, integer-, real-, and character-valued native data types.
- Full extensibility to support custom operators and new data types.
- Easy-to-use interface for novice and application users.
- Multiple levels of access for expert users.
- Parameterized population replacement.
- Multiple crossover, mutation, and selection operators.
- Easy integration of hill-climbing heuristics.
- Extensive debugging facilities.
- Large set of example problems.
- Detailed users guide.
- PIPE
Probabilistic Incremental Program Evolution (PIPE) is a novel
technique for automatic program synthesis. The software is written in C. It
- is easy to install (comes with an automatic installation tool).
- is easy to use: setting up PIPE_V1.0 for different problems
requires a minimal amount of programming. User-written, application-
independent program parts can easily be reused.
- is efficient: PIPE_V1.0 has been tuned to speed up performance.
- is portable: comes with source code (optimized for SunOS 5.5.1).
- is extensively documented(!) and contains three example applications.
- supports statistical evaluations: it facilitates running multiple
experiments and collecting results in output files.
- includes testing tool for testing generalization of evolved programs.
- supports floating point and integer arithmetic.
- has extensive output features.
- For lil-gp users: Problems set up for lil-gp 1.0 can be easily ported to PIPE_v1.0.
The testing tool can also be used to process programs evolved by
lil-gp 1.0.
- Sugal
Sugal [soo-gall] is the SUnderland Genetic ALgorithm system. The aim of
Sugal is to support research and implementation in Genetic Algorithms on a
common software platform. As such, Sugal supports a large number of variants
of Genetic Algorithms, and has extensive features to support customization
and extension.
These are various applications, software kits, etc. meant for research
in the field of evolutionary computing. Their ease of use will vary, as they
were designed to meet some particular research interest more than as
an easy to use commercial package.
- ADATE
ADATE (Automatic Design of Algorithms Through Evolution) is a system
for automatic programming i.e., inductive inference of algorithms,
which may be the best way to develop artificial and general
intelligence.
The ADATE system can automatically generate non-trivial and novel
algorithms. Algorithms are generated through large scale combinatorial
search that employs sophisticated program transformations and
heuristics. The ADATE system is particularly good at synthesizing
symbolic, functional programs and has several unique qualities.
- esep & xesep
This is a new scheduler, called Evolution Scheduler, based on
Genetic Algorithms and Evolutionary Programming. It lives with
original Linux priority scheduler.This means you don't have to
reboot to change the scheduling policy. You may simply use the
manager program esep to switch between them at any time, and
esep itself is an all-in-one for scheduling status, commands,
and administration. We didn't intend to remove the original
priority scheduler; instead, at least, esep provides you with
another choice to use a more intelligent scheduler, which
carries out natural competition in an easy and effective way.
Xesep is a graphical user interface to the esep (Evolution
Scheduling and Evolving Processes). It's intended to show users
how to start, play, and feel the Evolution Scheduling and
Evolving Processes, including sub-programs to display system
status, evolving process status, queue status, and evolution
scheduling status periodically in as small as one mini-second.
- Corewars
Corewars is a game which simulates a virtual machine with a number of
programs. Each program tries to crash the others. The program that
lasts the longest time wins. A number of sample programs are provided
and new programs can be written by the player. Screenshots are
available at the Corewars homepage.
- Corewar VM
This is a virtual machine written in Java (so it is a virtual machine
for another virtual machine !) for a Corewar game.
- FSM-Evolver
A Java (jdk-v1.0.2+) code library that is used to evolve finite
state machines. The problem included in the package is the
Artificial Ant problem. You should be able to compile the .java
files and then run: java ArtificialAnt.
- GPsys
GPsys (pronounced gipsys) is a Java (requires Java 1.1 or
later) based Genetic Programming system developed by Adil
Qureshi. The software includes documentation, source and
executables.
Feature Summary:
- Steady State engine
- ADF support
- Strongly Typed
- supports generic functions and terminals
- has many built-in primitives
- includes indexed memory
- Save/Load feature
- can save/load current generation to/from a file
- data stored in GZIP compression format to minimise disk
requirements
- uses serialisable objects for efficiency
- Fully Documented
- Example Problems
- Lawnmower (including GUI viewer)
- Symbolic Regression
- Totally Parameterised
- Fully Object Oriented and Extensible
- High Performance
- Memory Efficient
- Grany-3
Grany-3 is a full-featured cellular automaton simulator, made in C++
with Gtk--, flex++/bison++, doxygen and gettext, useful to granular
media physicists.
- JGProg
Genetic Programming (JGProg) is an open-source Java implementation of
a strongly-typed Genetic Programming experimentation platform. Two
example "worlds" are provided, in which a population evolves and
solves the problem.
Next
Previous
Contents
|
