chromoso.h

改算法基于遗传算法

// class of chromosome           
//                          Time-stamp: <2007-07-13 15:53:29 handa>

#include <iostream>
#include <vector>
#include <list>
#include <map>
#include "defs.h"
#include "random.h"

#ifndef CHROMOSO_H
#define CHROMOSO_H


using namespace std;

template<class T> class chromosome;
typedef chromosome<int> *chromoIntP;

template<class T> class environment {
  // This class is an example for OneMax Problem.
protected:
  int dim;
  random_number& rn;
  vector<T> ub;  vector<T> lb;
  T ubd;
  T lbd;
public:
  environment(int arg1, random_number& arg2): rn(arg2), ub(arg1), lb(arg1) { 
    dim = arg1;
  }
  environment(random_number& arg2): rn(arg2) { 
  }
  environment() {}

  virtual int isDim(void) {return dim; }
  virtual int noi() = 0;
  virtual int isNoFit() =0;
  virtual void generateMatchingSet(list<chromosome<T> *>& pop, 
				   list<chromosome<T> *>& matched, 
				   int i) = 0;
  virtual int superior(vector<double> fit1, vector<double> fit2) =0;
  virtual double calc(int dummy, chromosome<T>& arg) =0;
  virtual T newGene(int dim) {
    return (T) rn.urand(ub[dim]-lb[dim]) + lb[dim];
  }
  virtual T newGene(int dim, int pattern) = 0;
  virtual T newDecedent(int pattern) = 0;

  virtual T newDecedent() {
    return (T) rn.urand(ubd-lbd) + lbd;
  }
  virtual void setParam(double *arg) { ;}
  virtual int  paramSize() { return 0;}  // modified by wolf
  T lowerBound(int dim) { return lb[dim];  }
  T upperBound(int dim) { return ub[dim];  }
  environment<T>& operator=(const environment<T>& inp){
    if(this == &inp) return *this;
    rn     = inp.rn;
    dim    = inp.dim;
    ub     = inp.ub;
    lb     = inp.lb;
    return *this;
  }
};


template<class T> class chromosome{
protected:
  vector<T> string; 
  environment<T>& env;
  vector<double>   fit;
  // fitness function value(scaled and refferenced by GA)
  vector<double>   obj;
  // object function value( raw fitness set by fitness function)
  int feasible;
  double unWeighted;
  int flag;
  T decedent;
  

public:
  chromosome(environment<T>& arg): string(arg.isDim()), env(arg), fit(arg.isNoFit()), obj(arg.isNoFit()) {
    init();
    feasible = 1;
    flag = 0;
  } //constructor

  chromosome(environment<T>& arg, int pattern): string(arg.isDim()), env(arg), fit(arg.isNoFit()), obj(arg.isNoFit()) {
    init(pattern);
    feasible = 1;
    flag = 0;
  } //constructor
  double tempdata[5];  

  chromosome(const chromosome<T>& arg):env(arg.env) {
    string = arg.string;
    fit    = arg.fit;
    obj    = arg.obj;
    feasible = arg.feasible;
    unWeighted = arg.unWeighted;
    decedent = arg.decedent; 
  }   //copy constructor

  virtual void setFlag(int f) {flag = f;}
  virtual int isFlag() {return flag;}
  void init() {
    for(int i =0; i < env.isDim();i++) {
      string[i] = env.newGene(i);
    }
    decedent = env.newDecedent();
  }

  void init(int pattern) {
    for(int i =0; i < env.isDim();i++) {
      string[i] = env.newGene(i, pattern);
    }
    decedent = env.newDecedent(pattern);
  }
  int&  isFeasible() { return feasible; }
  double& isUnWeighted() { return unWeighted;}
  int  isDecedent() { return decedent;}
  void setDecedent(int arg) { decedent = arg;}

  int find(T val) {
    for (int i = 0; i < string.size(); i++) 
      if (string[i] == val) return i;
    return -1;
  }
      
  void   setgene(int p, T data){
    if((env.upperBound(p) >= data) && 
       (env.lowerBound(p) <= data) &&
       (0 <= p) &&
       (env.isDim() > p)) 
      string[p] = data;
    else
      cout << "Error is occurred." << endl 
	   << "ub is " << env.upperBound(p) << endl
	   << "lb is " << env.lowerBound(p) << endl
	   << "data is " << data << endl
	   << "p  is " << p << endl;    
  }
  T   getgene(int l) { return string[l]; }
  T   getub(int l)   { return env.upperBound(l); }
  T   getlb(int l)   { return env.lowerBound(l); }
  vector<double>& fitness(){ return fit;}
  double& fitness(int i){ return fit[i];}
  vector<double>& objfunc(){ return obj;}
  double& objfunc(int i){ return obj[i];}
  int Size(){ return env.isDim();}
  
  chromosome<T>& operator=(const chromosome<T>& inp){
    if(this == &inp) return *this;
    string = inp.string;
    flag   = inp.flag;
    env    = inp.env;
    fit    = inp.fit;
    obj    = inp.obj;
    feasible    = inp.feasible;
    unWeighted    = inp.unWeighted;
    for(int i = 0; i < 5; i++) tempdata[i] = inp.tempdata[i];
    return *this;
  }

};


#endif