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.
A collection of programs using evolved artificial neural networks to solve a series of problems. The long term goal of the project is to advance our level of understanding about simulated evolution as a means to configure and optimize Artificial Neural Nets (ANNs). The medium term goal is to apply our methods to a series of interesting problems such as sail boat piloting and playing the game NIM.
A secondary goal is educational in nature. We attempt to write our software with ample explanation, not just for the user, but for the engineer/programmer/scientist who wants to understand the innermost detail. All of the source code is freely available to anyone to use without restriction.
All of the ANNEvolve software is implemented in C and Python.
EAP has been built using the Python and UNIX programming philosophies in order to provide a transparent, simple and coherent environment for implementing your favourite evolutionary algorithms. EAP is very easy to use even for those who do not know much about the Python programming language. EAP uses the object oriented paradigm that is provided by Python in order to make development simple and beautiful. It also contains a 15 illustrative and diversified examples, to help newcomers to ramp up very quickly in using this environment.
It includes Genetic Algorithms using any imaginable representation, Genetic Programming with strongly and loosely typed trees in addition to automatically defined functions, Evolution Strategies (including Covariance Matrix Adaptation), multiobjective optimization techniques (NSGA-II and SPEA2), easy parallelization of algorithms and much more like milestones, genealogy, etc.
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.
DEAP is intended to be an easy to use distributed evolutionary algorithm library in the Python language. Its two main components are modular and can be used separately. The first module is a Distributed Task Manager (DTM), which is intended to run on cluster of computers using TCP or a MPI connection. The second part is the Evolutionary Algorithms in Python (EAP) framework. EAP is the evolutionary core of DEAP, it provides data structures, methods and tools to design any kind of evolutionary algorithm. It works in perfect harmony with DTM, allowing easy parallelization of any demanding evolutionary task.
The Distributed Genetic Programming Framework (DGPF) is a scalable Java environment for heuristic, simulation-based search algorithms of any kind and Genetic Algorithms in special. We use the broad foundation of a search algorithms layer to provide a Genetic Programming system which is able to create Turing-complete code.
It's under the LGPL license. It allows you to use heuristic searches like GA and randomized Hill Climbing for any problem space you like to with just minimal programming effort. Also, you may distribute all these searches over a network, using the client/server, the peer-to-peer, or even a client/server+ peer-to-peer hybrid distribution scheme. You also can construct heterogeneous search algorithms where GA cooperates with Hill Climbing without changing any code.
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 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.
Evocosm is a set of classes that abstract the fundamental components of an evolutionary algorithm. See the site for details, but here is a simple list of the provided classes; Random Numbers, OpenMP, Floating-Point Chromosomes, Roulettte Wheels, Organisms, Fitness Landscapes, Evocosms, Fitness Scaling, Migration, Selecting Survivors, Reproduction, Mutation Operations.
A Python library for creating and working with genetic algorithms and genetic (evolved) programs. Allows one to do Python-based evolutionary programming; string-based as well as source code tree node optimization/search solution discovery.
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.
FREVO is an open-source framework developed in Java to help engineers and scientists in evolutionary design or optimization tasks. The major feature of FREVO is the componentwise decomposition and separation of the key building blocks for each optimization tasks. We identify these as the problem definition, solution representation and the optimization method. This structure enables the components to be designed separately allowing the user to easily swap and evaluate different configurations and methods or to connect an external simulation tool.
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 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:
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.
The Genetic Algorithm Utility Library (GAUL) is a flexible programming library designed to aid development of applications that require the use of genetic algorithms. Features include:
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.
GenePool is a framework for writing evolutionary optimization algorithms in OCaml. This library is not a complete solution but rather is a generic skeleton which takes care of the plumbing and nuisances of optimization. You provide GenePool with functions that give meaning to fitness and reproduction and after a specified number of generation, GenePool returns an array of the best "genomes" it evolved.
This is a package for genetic algorythms and AI in Python.
Genetic can typically solve ANY problem that consists to minimize a function.
It also includes several demos / examples, like the TSP (traveling saleman problem).
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:
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:
Simple genetic algorithm package written in Java.
JGAP (pronounced "jay-gap") is a Genetic Algorithms and Genetic Programming component provided as a Java framework. It provides basic genetic mechanisms that can be easily used to apply evolutionary principles to problem solutions.
JGAP was designed to be very easy to use "out of the box", while also designed to be highly modular so that more adventurous users can easily plug-in custom genetic operators and other sub-components.
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:
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.
Open BEAGLE is a C++ evolutionary computation framework. It provides a high-level software environment to do any kind of evolutionary computation, with support for tree-based genetic programming, bit string and real-valued genetic algorithms, evolution strategy, co-evolution, and evolutionary multi-objective optimization.
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:
Probabilistic Incremental Program Evolution (PIPE) is a novel technique for automatic program synthesis. The software is written in C. It ...
A Common Lisp framework for experimenting with meta-optimizing semantic evolutionary search ( MOSES) and related approaches to learning with probability distributions over program spaces based on:
Pyevolve was developed to be a complete genetic algorithm framework, the main objectives of Pyevolve are:
Your basic genetic algorithm package for python.
Small genetic programming library in C++ and ActionScript 3 (Javascript engine embedded in Flash) with flash demos.
This GP library uses the standard Koza expression tree program representation. It uses the 'grow' algorithm to generate random expressions. Mutation is performed by selecting a random subexpression in an expression tree, and replacing it with a new random expression (which satisfies the maximum tree depth constraint). Crossover (mating) between two expressions is performed by selecting a random subexpression in each parent, then exchanging them (although it only makes on child, not two).
In addition to the core code for creating, mutating, mating and evaluating expressions, the library includes a steady-state genetic algorithm with tournament selection, and a worst-out, elitist replacement policy (i.e. when a new child is created, it replaces the worse member of the population, only if it is better).
A Twisted-based set of libraries for performing calculations of genetic algorithms as well as genetic programs in an asynchronous, distributed manner.
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 (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.
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 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.
JCASim is a general-purpose system for simulating cellular automata in Java. It includes a stand-alone application and an applet for web presentations. The cellular automata can be specified in Java, in CDL, or using an interactive dialogue. The system supports many different lattice geometries (1-D, 2-D square, hexagonal, triangular, 3-D), neighborhoods, boundary conditions, and can display the cells using colors, text, or icons.
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.