Title: | Evolving Objects | Type: | Tool |
---|---|---|---|

Genre: | Development | Status: | |

Category: | Development ➤ Framework & Tool | Commercial: | |

Tags: | Development; Framework; C/C++; Multi-platform | Demo: | |

Released: | Latest : 1.3.1 / Dev : 7e4bc9 | Package Name: | |

Date: | 2012-02-10 | Extern Repo: | |

License: | LGPL v3 | Deb Repo: | |

View: | Package: | ||

Graphic: | Binary: | ||

Mechanics: | Source: | ||

Played: | Single & Multi | PDA: | |

Quality (record): | Quality (game): | ||

Contrib.: | Goupil & Louis | ID: | 14213 |

Created: | 2014-03-08 | Updated: | 2020-02-09 |

[fr]: | Une bibliothèque de calcul évolutionniste permettant de concevoir des algorithmes d'optimisation stochastique | [en]: | An evolutionary computation library which helps you to write your own stochastic optimization algorithms insanely fast |
---|

**Website & videos**

[Homepage] [Dev site] [Features/About] [Screenshots] [Videos t ts gd id r lp g g[fr] g[de] g[ru] g[pl] g[cz] g[sp] g[pt] g[it] g[tr] g] [Reviews] [WIKI 1 2] [FAQ] [RSS] [Changelog 1 2 3]**Commercial** : (empty) **Resources**

• (empty) **Technical informations**

[Open Hub] [PCGamingWiki] [MobyGames] **Social**

Devs (Evolving Objects Team [fr] [en]) : [Site 1 2] [twitter] [YouTube] [Interview 1 2]

Game : [Blog] [Forums] [twitter] [YouTube]**On other sites**

[Wikipedia (Evolutionary algorithm) [fr] [en]]

[Wikipedia (Stochastique / Stochastic) [fr] [en]] **Reviews****News / Source of this Entry (SotE) / News (SotN)**

Une bibliothèque de calcul évolutionniste permettant de concevoir des algorithmes d'optimisation stochastique, par la Evolving Objects Team.

En C++

Evolving Objects (EO) est une bibliothèque ANSI-C++ de calcul évolutionniste basée sur des templates, permettant de concevoir des algorithmes d'optimisation stochastique incroyablement rapide.

Les algorithmes évolutionnaires forment une famille d'algorithmes inspirés par la théorie de l'évolution, qui permettent de résoudre divers problèmes. Ils évoluent en un ensemble de solutions à un problème donné, afin de produire les meilleurs résultats. Ce sont des algorithmes stochastiques, car ils utilisent de manière itérative des processus aléatoires. La grande majorité de ces méthodes sont utilisées pour résoudre des problèmes d'optimisation, et peuvent également être appelées "métaheuristiques". Elles sont également classées parmi les méthodes de l'intelligence informatique, un domaine proche de l'intelligence artificielle.

Avec EO, vous pouvez facilement concevoir des algorithmes évolutionnaires qui trouveront des solutions à pratiquement tous les difficiles problèmes d'optimisation, des problèmes continus aux problèmes combinatoires.** Utilisé par ces jeux / Used by these games** : GeneticInvasion,

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.

Introduction

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

It contains classes for almost any kind of evolutionary computation you might come up to - at least for the ones we could think of. 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 classes.

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.

Overall Design

EO is a framework. It is oriented toward facilitating the design of adhoc evolutionary algorithms. It is not (at the moment) a complete library of algorithms ready to use on canonical problems.

If you have a well-known problem and want to solve it as soon as possible, try another software. If you have a real problem and want to build the best evolutionary algorithm to solve it, you've made the good choice.

Bascially, EO manipulate "individuals" with a "fitness", that is objects encoding a solution to a given optimization problem, associated with the quality of this solution. The fitness is defined in the EO class, but the representation of a solution cannot be as generic. Thus, EO massively use templates, so that you will not be limited by interfaces when using your own representation.

Once you have a representation, you will build your own evolutionary algorithm by assembling Evolutionary Operators in Algorithms. In EO, most of the objects are functors, that is classes with an operator(), that you can call just as if they were classical functions. For example, an algorithm is a functor, that manipulate a population of individuals, it will be implemented as a functor, with a member like: operator()(eoPop

Generally, operators are instanciated once and then binded in an algorithm by reference. Thus, you can easily build your own algorithm by trying several combination of operators.

☑ Main Features

• 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.