Modular and highly reconfigurable algorithms

An algorithm in Jenes is structured in composable components, termed stages. The population passes through the stages and there it is transformed. Each stage receive an input population and produce an output population. All stages are interchangeable. This makes possible to strucutre an algorithm that best fits the problem characteristics and user needs, just deciding how to organize the flow trough the stages. Stages regarding the strucuture are the sequenxe and the parallel, wilst operators are elementary stages performing tasks such as selection, crossover and mutation. The user can assembly its own algorithm deciding the structure and wich operators to use, such as choosing between the Wheel or Tournament selection, or bewtween a single point or two points crossover, and so on.

Optimized architecture and memory usage

Special attention has been paid to code optimizations in Jenes. The most important regards the memory usage. Objects are continously recycled. This permits to reduce the overhead provided by the garbage collection. If the population size is fixed along the algorithm ecvolution, the memory occupation grows at the beginning and does not change after. This allows to reduce the overall software footprint and time for building and collecting objects. The chromosome footprint is reduced, such as in the case the BitwiseChromosome able to work at the level of single bits, thus outperforming other solutions. Moreover, individuals already evaluated are not re-evaluated int the following iterations.

Strong type checking

Jenes data types are strongly typed, so population and individualsĀ  can olnly work with compatible types. This pemits to reduce the number of checks at runtime, as the use of parametric classes assures at compile that the right data type is used. This also entails that there is no need of casting objects. This results in better software reliability and speed. '

Written in Java 1.5

Finally, Jenes is written in Java 1.5 or following releases. This choice was in order to provide a richer type checking set and to reduce the overhead of typing checking at runtime.

Planned Features

  • A GUI Interface for a faster algorithm setup
  • Multithreading for multicore processors
  • Support for distributed and grid computing
  • A richer set of chromosomes and genetic operators
  • Parameters autotuning