[ale] ANNOUNCE: Evolvuton - Framework for Evolutionary Computing

Omar Loggiodice ologgio at vrainn.com
Sun Feb 1 14:42:07 EST 1998


Hi,

   I am pleased to announce the public release of Evolvuton, a
framework for generic evolutionary computing. In developing this
framework, care has been taken to make it as generic as possible.
Currently the component is a C++ template library, that follows
many of the design guidelines that STL has introduced in the C++
world; namely, generic programming. What I have tried to achieve
is to produce an evolutionary framework that would allow other C++
developers to use evolutionary algorithms in the context of their
own application, imposing minimal restrictions on their
application. Some of the features of the Evolvuton component are:

* It does not require a numeric fitness function, or for that
matter, a fitness function at all (you can use one if you want to
though).

* Allows implicit or explicit fitness by selecting individuals on
the basis of a "less-than-operator".

* A C++ class (as opposed to a numeric type) can be used to
specify the fitness function - allowing non-numeric fitness to be
used.

* A population object, which is part of the Evolvuton framework,
conforms to the requirements of an STL container, allowing the use
of all the algorithms available via the Standard Template Library
(STL).

* It provides a decoupled (from the problem domain) generic
evolution framework because doesn't impose a particular
representation of the problem domain. This gives tremendous
flexibility to the developer, and solves one of the major problems
that is typically found with genetic algorithms - that of trying
to represent the problem domain as a string of bits.

* LaTeX and HTML documentation is provided.

* It only requires a few member functions that need to be
implemented in order to allow your objects to evolve. Namely: a
copy constructor, a less-than operator, a
getRandomCharacteristicFrom(), and a mutate() member function.

All the development is done in Linux, using the egcs compiler
(based on GNU gcc 2.8.0). It should be fairly easy to port/use
with other compilers that support STL. If you use/port it to
another platform please join the mailing list and send patches
so that we can make the improvements available to others. You
can join the mailing list by sending email to
evolvuton-request at vrainn.com with the word "subscribe" in the
subject.


Status
======

   This software should be considered as work-in-progress, and it
has been released publicly to allow the community of developers,
researchers and enthusiasts to have early access to the project.
I believe in the bazaar model of free software development (see
below), hence I plan to release "early and often", which is why
this announcement is being made :). If you don't have C++
knowledge the software is not very useful to you, because this is
a C++ component to be used in conjunction with your libraries or
applications. The release is directed at developers that are
interested in helping with the project, or in using Evolvuton for
their applications. Because it is an early release, I can't
guarantee that the interface or the software is stable; the
documentation also needs work. This software should not be
considered a production release, it is a developers pre-alpha
release. However, if you have C++ knowledge I encourage you to
take a look at it and see how you can take advantage of using
evolutionary algorithms in your application/library. Please join
the effort, and post your ideas/code in the mailing list!

For more information about the "Bazaar vs. the Cathedral" model of
software development see:
http://sagan.earthspace.net/~esr/writings/cathedral-bazaar/


The "Bazaar vs. Cathedral" paper, BTW, has had a major influence in
the commercial world also: Netscape's decision to release the
browser source code publicly was heavily influenced by the paper.
Please check the URL above for more information.

How to contribute
=================

   I'm glad you're thinking about contributing! This software will
hopefully grow based on the contributions of people like you. The
first thing I would recommend to do is to join the mailing list by
sending email to evolvuton-request at vrainn.com with the word
"subscribe" in the subject. Make sure you post to the list to let
other people know what you're working on. You can work on the
evolvuton component itself, or on some of the components that use
it, like the investbot component. Those of you interested in using
evolutionary computation to invest in the stock market might want
to join and help out with the investbot component.


How to Get the software
=======================

   You can get the software from:
   ftp://ftp.vrainn.com/pub/components/components-x.y.z.tar.gz

   Where x.y.z is the version. For example, version 0.3.1 is
called components-0.3.1.tar.gz.

   This is a slow link to the net, so please be patient :) If you
want to mirror the site, I would really appreciate it, you can
email me at ologgio at vrainn.com .

   The components-x.y.z.tar.gz file contains several components:
   
   evolvuton        The generic evolution framework.
   ookit            Typically used utilities, such as cache,
                    shared pointers, dates, etc.
   stock            A component to read stock data.
   investbot        A component to invest in the stock market 
                    using evolutionary algorithms (uses the evolvuton
		    component).

More information, Mailing list, WWW, etc.
=========================================

   More information, and the HTML documentation, can be found on
the Evolvuton web pages, at http://www.vrainn.com/evolvuton/ , if
you're interested in the development and usage of Evolvuton you
should also join the mailing list by mailing
evolvuton-request at vrainn.com with the word "subscribe" in the
subject. At this point, the mailing list will be used to discuss
the evolvuton component itself, and some of the other components
that use it, such as the investbot component that uses
evolutionary computation to invest in stocks. If the volume grows
too large, we'll split the mailing list into an evolvuton specific
one and an application specific list.

A simple example
================

   For the sake of the example, let's assume you have a class
called bitEvolvuton. This class represents an object with 32 bits
and provides a mutate() member, which mutates the object. It also
provides a getRandomCharacteristicFrom(bitEvolvuton& be2) member
and a constructor that can generate a random object. The
getRandomCharacteristicFrom() member selects a "random
characteristic" from be2 and merges that characteristic into the
current object (it is used for crossover operations).

   Let's assume that the fitness of the object is the unsigned
integer that the string of 32 bits represents (and it is known by
the bitEvolvuton object).

Given this scenario, you could evolve a population of
bitEvolvutons by using the following code (you can find the
bitEvolvuton source in the test directory of the evolvuton
component):


#include "evolvuton/evolvuton"
#include "BitEvolvuton.h"

int main(int argc, char **argv)
{
   const BitEvolvuton *ep;

   // Population is 50 evolvutons
   Population<BitEvolvuton> pop(50);

   // The population size is kept constant because the mutation index,
   // the crossover index and the reproduction index add up to 1. 
   pop.setMutationIndex(0.20);
   pop.setCrossoverIndex(0.50);
   pop.setReproductionIndex(0.30);
   
   do 
   {
      pop.nextGeneration();        // Produce the next generation
      ep = &pop.boaGenerations();  // Keep a pointer to the best-of-all
                                   // generations object
				   
   // Stop! We found the perfect bitEvolvuton!				   
   } while ( ep->getFitness() != ULONG_MAX ); 
                                              

   cout << "Perfect bitEvolvuton found in " << pop.generation() 
	<< " generations." << endl
        << "Population   size   is " << pop.size()
	<< " evolvutons." << endl;
}     

As you can see, the population class template is parametrized by
the type of evolvuton you want to use. This makes the algorithm
applicable to any class that can be adapted to provide the
required member functions. A Class template to ease the
development of explicit fitness evolvutons is also included. The
bitEvolvuton example is used as the test case for the evolution
component, and it normally finds the perfect evolvuton in 18 to 80
generations.

   You can also see the HTML documentation in the doc/html
directory. Use your favorite browser and point it to that
directory.

Legalese
=========

   I have gained much in my life from the Free Software Community. I've used
and have promoted the use of quality free software for many years. With that
in mind you can be sure that a current version of this software will always
be freely available for non-military use.

The software is Copyrighted by myself, and it is distributed under the terms
of the GNU GPL (General Public License) with the additional
restriction that the software can not be used for military purposes.

Make sure you send an email saying how you're using it how it helped with
your application/project. Please see the LICENSE file for the actual legal
stuff.


Best regards,
   Omar Loggiodice <ologgio at vrainn.com>
   Atlanta, GA, USA.




____________________________________________________________________
            /   __  __  __  - __  __ / - _  __  ologgio at vrainn.com
  Omar R.  /__ /_/ /_/ /_/ / /_/ /_/ / /_  /-_  CIS: 74040,1543
                  __/ __/                         
___C++/7_yrs____Virtual Reality/4_yrs____Vorl_____Linux(free)_______
The STL paradigm: Decouple your objects, strengthen requirements






More information about the Ale mailing list