/evolving-objects

Evolving Objects (EO): an Evolutionary Computation Framework

Primary LanguageC++

Evolving Objects logo

C++ evolutionary computation components framework

Shortcuts

Get Evolving Objects at SourceForge.net. Fast, secure and Free Open Source software downloads

Evolving Objects (EO): an Evolutionary Computation Framework

EO is a template-based, ANSI-C++ evolutionary computation library which helps you to write your own stochastic optimization algorithms insanely fast.

Evolutionary algorithms forms a family of algorithms inspired by the theory of evolution, that solve various problems. They evolve a set of solutions to a given problem, in order to produce the best results. These are stochastic algorithms, because they iteratively use random processes. The vast majority of these methods are used to solve optimization problems, and may be also called "metaheuristics". They are also ranked among computational intelligence methods, a domain close to artificial intelligence.

With the help of EO, you can easily design evolutionary algorithms that will find solutions to virtually all kind of hard optimization problems, from continuous to combinatorial ones.

Download

If you need immediate support or have any question, the best way to get answers is to subscribe to the mailing list and send your email to eodev-main@lists.sourceforge.net

Alternatively, you can join us on the official chatroom. You can try our webchat interface, or if you already use IRC, you can directly connect to the irc.freenode.org/#paradiseo multi-user chatroom with your favorite client.

Features

Component-based framework

Designing an algorithm with EO consists in choosing what components you want to use for your specific needs, just as building a structure with Lego blocks.

If you have a classical problem for which available code exists (for example if you have a black-box problem with real-valued variables), you will just choose components to form an algorithm and connect it to your fitness function (which computes the quality of a given solution).

If your problem is a bit more exotic, you will have to code a class that represents how your individuals (a solution to your problem) are represented, and perhaps some variations operators, but most of the other operators (selection, replacement, stopping criteria, command-line interface, etc.) are already available in EO.

"A typical Evolutionary Algorithm, as seen from the EO point of vue − Johann Dréo − CC-BY-SA")

Main Features

Examples of problems that you can solve with the help of EO:

"Continuous problems (here Gallagher's Gaussian 101-me Peaks function, Black Box Optimization Benchmark, f21 − COCO team)"

"Graph problems (here a Hue scale representing node betweenness on a graph − Claudio Rocchini − CC-BY)"

"Planning problems (here a Gantt Chart for a Batch Process − Casilett − DP)"

  • Flexible design that permits to easily create virtually any algorithm
  • Solution representation for continuous and combinatorial problems:
    • binary-strings,
    • permutations,
    • vectors,
    • easily write your own,
    • …
  • Several algorithm paradigms:
    • evolution strategies,
    • genetic algorithms,
    • estimation of distribution,
    • particle swarm optimization
    • …
  • Many selection and replacement operators:
    • rank-based,
    • deterministic or stochastic tournaments,
    • roulette,
    • elitism,
    • …
  • Ready-to-use variations operators:
    • uniform initializer,
    • gaussian mutation,
    • subtree crossover,
    • …
  • Easy combination of several operators:
    • proportional combination,
    • sequential call,
    • …
  • Parallelization tools:
    • Shared memory loops unrolling (with OpenMP)
    • Message passing parallelization (with openMPI):
      • map/reduce-like design, with operators choice, as in EO
      • useful existing operators (parallel dynamic multi-start, static evaluations, …)
  • Portable and human-readable parameter files
  • Suspend and load population from files
  • Versatile checkpointing and logging:
    • graphical display,
    • file dump,
    • various statistics,
    • signal catching,
    • …
  • Mersenne Twister random number generator (and various distributions)
  • No useless computation (sparing fitness call, functor-based calls)
  • Fast running speed, thanks to C++
  • And more!

Portability

EO should work on Windows and any Un*x-like operating system with a standard-conforming C++ development system.

Recent versions of EO have been tested on the following platforms:

  • Linux x86 with GCC 3.x and 4.x
  • Linux x86_64 with GCC 3.x and GCC 4.x
  • MacOS X/Darwin PowerPC with GCC 3.x
  • MacOS X/Darwin x86 with GCC 4.x
  • Microsoft Windows using Cygwin's GCC 3.x (cygming special).
  • Microsoft Windows using Visual Studio 2003/2005; projects files are provided.
  • Solaris SPARC with GCC 3.x
  • Solaris x86 with GCC 3.x

Recent versions of EO uses the CMake portable build system, that permits to easily generate a build chain for your environment.

If you have tested EO on a system not listed here, please let us know.

If you are working on a system with an older C++ compiler there is a good chance that eo-0.9.3z.1 works. It is tested on Linux with gcc-2.9x and several systems (IRIX, Solaris) with egcs.

Presentations

A functional and "philosophical" overview of EO was presented at EA'01 conference. You can download the paper or the slides.

You can also read this PowerPoint presentation, that shows the EO philosophy. It includes a Visual Basic macro for evolving objects in Visual Basic for Applications.

If you want to understand the message-passing parallelization module, check the introduction to eo::MPI by Benjamin Bouvier.

Here is a list of some known publications that used EO:

Code

Download

The current stable release is EO 1.0. It supports any standard-compliant C++ compiler.

You can obtain the latest version directly via GIT or browse the repository online.

All releases can be obtained from the SourceForge download area.

License

EO is distributed under the GNU Lesser General Public License.

Note that this license places copyleft restrictions on a program created with EO, but does not apply these restrictions to other software that would links with the program.

Documentation

The tutorial demonstrates that writing an evolutionary algorithm evolving your own structures is now easy, using ready-to-use template files. Although the tutorial has not been upgraded for some time now and refers to version 0.9.2 of EO, it nevertheless remains the best way to dive into EO. You can start by trying it on-line at LRI or SourceForge, before downloading it. The tutorial is also included in the released sources.

The latest tutorial release.

The complete code is also well documented and you can look at the generated interface documentation.

The easiest way to create a complete new EO-project, even for new genomes, is to use the script provided in tutorial/Templates/; see the README in that directory and lesson 5 of the tutorial for detail.

Development

Mailing-lists

EO is an open development effort; that is why we have created mailing lists to discuss future developments, solve technical problems, announce releases, publish patches, and discuss evolutionary computation in general. Browse the archives or join the EO mailing lists.

Get involved

The following resources are available, thanks to sourceforge

Related software

The softwares listed here are using EO, but they are not maintained by the EO team. They may not be free softwares or may even be outdated.

  • ParadisEO provides EO extensions for the flexible design of single solution-based metaheuristics, metaheuristics for multi objective optimization as well as hybrid, parallel and distributed metaheuristics.
  • DegaX is an ActiveX control which embeds EO 0.8.4.
  • EASEA was a GUI that permits to build evolutionary algorithm with EO or the GAlib. It is now a platform that allows program evolutionary algorithms on massively parallel many-core architectures.
  • GUIDE is a GUI that allows the generation of evolutionary algorithms. It can use EO or ECJ.

Authors

EO was started by the Geneura Team at the University of Granada, headed by Juan Julián Merelo. The original Web site is also the only place where you will find old releases of EO (up to 0.8.7), but beware that it is not compatible at all with the current version.

The developement team has then been reinforced by Maarten Keijzer, the C++ wizzard, and Marc Schoenauer. Later came Jeroen Eggermont, who, among other things, did a lot of work on GP, INRIA Dolphin Team, Olivier König, who did a lot of useful additions and cleaning of the code and Jochen Küpper, working on infrastructure maintenance.

The project is now maintained by Johann Dréo, working on it with the help of Caner Candan. Benjamin Bouvier have designed a whole new MPI parallelization module.

Links