gp.h

用C++编写的遗传算法

// gp.h

/* -------------------------------------------------------------------

gpc++ - The Genetic Programming Kernel

This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 1, or (at your option)
any later version.

This program is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.


Copyright 1993, 1994 Adam P. Fraser and 1996, 1997 Thomas Weinbrenner

For comments, improvements, additions (or even money) contact:

Thomas Weinbrenner
Grauensteinstr. 26
35789 Laimbach
Germany
E-mail: [e-mail]
WWW:    http://www.emk.e-technik.th-darmstadt/~thomasw

  or 

(Address may be out of date)
Adam Fraser, Postgraduate Section, Dept of Elec & Elec Eng,
Maxwell Building, University Of Salford, Salford, M5 4WT, United Kingdom.
E-mail: [e-mail]
Tel:    (UK) 061 745 5000 x3633
Fax:    (UK) 061 745 5999

------------------------------------------------------------------- */

// Genetic Program class definitions



#ifndef __GP_H
#define __GP_H

#include <iostream.h>



// Version and copyright message
extern char* GPVersion;
void GPPrintCopyright (ostream& os);

// Make internal checks or not. Better do it... it saved me a lot of
// work I can tell.  It results in a speed loss of roughly 3%, that is
// less than it sounds.  A good, optimising compiler can do much more
// here.
#define GPINTERNALCHECK 1

// If an error occurs (GPExitSystem()), a segmentation fault helps
// debugging the code to find the location that caused the error
#define GPCREATE_SEGMENTATIONFAULT_ON_ERROR 1

// Random number functions for gp system
void GPsrand (long);
long GPrand ();
int GPRandomPercent (double percent);

// Init and exit
void GPInit (int printCopyright, long seedRandomGenerator);
void GPExitSystem (char *functionName, char *errorMessage); 

// Registering for load/save
class GPObject;
GPObject* GPCreateRegisteredClassObject (int ID);
void GPRegisterClass (GPObject* gpo);
void GPRegisterKernelClasses ();

// Every class gets an unique identification number that is returned
// by the function isA().
#define GPObjectID       1
#define GPContainerID    2
#define GPNodeID         3
#define GPNodeSetID      4
#define GPAdfNodeSetID   5
#define GPVariablesID    6
#define GPGeneID         7
#define GPID             8
#define GPPopulationID   9
#define GPUserID        50



// ------------------------------------------------------------------



// The base class for all other classes.  This is an abstract class.
// The destructor is virtual.

class GPObject
{
public:
  GPObject () {}
  virtual ~GPObject () {}

  GPObject (const GPObject&) {}
  // Duplicate object. This function must be provided by every
  // inheriting class!!!
  virtual GPObject& duplicate ()=0;

  virtual int isA ()=0;
  virtual char* load (istream& is)=0;
  virtual void save (ostream& os)=0;
  virtual GPObject* createObject()=0;

  // Print function. It's virtual, so only one operator << is needed.
  virtual void printOn (ostream& os)=0;
};

// Print operator for all classes that inherit from GPObject
inline ostream& operator << (ostream& os, GPObject& gpo)
{
  gpo.printOn (os);
  return os;
}



class GPContainer : public GPObject
{
public:
  GPContainer ();
  GPContainer (int numObjects);
  virtual ~GPContainer ();

  GPContainer (const GPContainer& gpc);
  virtual GPObject& duplicate () { return *(new GPContainer(*this)); }

  virtual void printOn (ostream& os);

  void reserveSpace (int numObjects);

  int containerSize() const { return contSize; }

  GPObject* Nth (int n) const;
  GPObject** getPointerAddress (int n) const;
  void put (int n, GPObject& gpo);
  GPObject& get (int n);

  virtual int isA () { return GPContainerID; }
  virtual char* load (istream& is);
  virtual void save (ostream& os);
  virtual GPObject* createObject() { return new GPContainer; }

  GPContainer& operator = (GPContainer& gpo) {
    GPExitSystem ("operator =", "Assignment operator not yet implemented"); 
    return gpo; }

protected:
  void deleteContainer ();

  // The actual container is an array of pointers to GPObject
  GPObject** container;
  // The container size
  int contSize;
};



// ------------------------------------------------------------------



class GPNode : public GPObject
{
public:
  GPNode () { nodeValue=0; numOfArgs=0; representation=0; }
  GPNode (int nVal, char* str, int args=0) : nodeValue(nVal), 
      numOfArgs(args) { representation=copyString (str); }
  virtual ~GPNode () { delete [] representation; }

  GPNode (const GPNode& gpo);
  virtual GPObject& duplicate () { return *(new GPNode(*this)); }

  virtual void printOn (ostream& os) { os << representation; }

  int value () { return nodeValue; }
  int isFunction () { return numOfArgs!=0; }
  int isTerminal () { return numOfArgs==0; }
  int arguments () { return numOfArgs; }

  virtual int isA () { return GPNodeID; }
  virtual char* load (istream& is);
  virtual void save (ostream& os);
  virtual GPObject* createObject() { return new GPNode; }

  GPNode& operator = (GPNode& gpo) {
    GPExitSystem ("operator =", "Assignment operator not yet implemented"); 
    return gpo; }

protected:
  // The nodes numerical value, the number of arguments it takes (0 if
  // it is a terminal) and its string representation.  We operate on a
  // duplicate
  int nodeValue;
  int numOfArgs;
  char* representation;

  char *copyString (char *s);
};



class GPNodeSet : public GPContainer
{
public:
  GPNodeSet () { numFunctions=0; numTerminals=0; }
  GPNodeSet (int numOfNodes) : GPContainer (numOfNodes) {
    numFunctions=0; numTerminals=0; }

  GPNodeSet (const GPNodeSet& gpo) : GPContainer(gpo) { 
    numFunctions=gpo.numFunctions; numTerminals=gpo.numTerminals; }
  virtual GPObject& duplicate () { return *(new GPNodeSet(*this)); }

  virtual void put (int, GPObject&);
  virtual void putNode (GPNode& gpo);

  virtual void printOn (ostream& os);

  virtual GPNode* searchForNode (int value);
  GPNode* NthNode (int n) {
    return (GPNode*) GPContainer::Nth (n); }

  virtual GPNode& chooseFunction();
  virtual GPNode& chooseTerminal();
  virtual GPNode* chooseNodeWithArgs (int args);

  virtual int isA () { return GPNodeSetID; }
  virtual char* load (istream& is);
  virtual void save (ostream& os);
  virtual GPObject* createObject() { return new GPNodeSet; }

  GPNodeSet& operator = (GPNodeSet& gpo) {
    GPExitSystem ("operator =", "Assignment operator not yet implemented"); 
    return gpo; }

protected:
  // Container contains functions from 0..numFunctions-1 and terminals
  // from containerSize()-1-numTerminals..containerSize()-1
  int numFunctions, numTerminals;
};



class GPAdfNodeSet : public GPContainer
{
public:
  GPAdfNodeSet () {}
  GPAdfNodeSet (int numOfTrees) : GPContainer(numOfTrees) {}

  GPAdfNodeSet (const GPAdfNodeSet& gpo) : GPContainer(gpo) {}
  virtual GPObject& duplicate () { return *(new GPAdfNodeSet(*this)); }

  // As we have no variables, we leave load and save to our container
  // class
  virtual int isA () { return GPAdfNodeSetID; }
  virtual GPObject* createObject() { return new GPAdfNodeSet; }

  virtual void printOn (ostream& os);

  GPNodeSet* NthNodeSet (int n) { 
    return (GPNodeSet*) GPContainer::Nth (n); }

  GPAdfNodeSet& operator = (GPAdfNodeSet& gpo) {
    GPExitSystem ("operator =", "Assignment operator not yet implemented"); 
    return gpo; }
};



// ------------------------------------------------------------------



// Prototypes
class GP;
class GPPopulation;