efile.h

此程序为多目标粒子群程序

      _delparticles.push_back(_i);
      erase.push_back(true);
    }
    else erase.push_back(false);
  }
  if(_delparticles.size()>0)
  updateClusters(_delparticles);

   vector<bool>::iterator _iterator=erase.begin();
   vector<Particle>::iterator _iterator2=solutions.begin();
   int _delindicator(0);
   for(_iterator=erase.begin(); _iterator != erase.end();++_iterator,_delindicator) {
     if(*_iterator==true){
       solutions.erase(_iterator2);
       nsolutions--;
     }
     else
       _iterator2++;
   }
  if(_flag==true){
    if(nsolutions>=maxsolutions+maxsolutions/10){
      update();
      add(_particle);
      return _flag;
    }
    else{
      if(_whichcluster!=-1)add2Cluster(_whichcluster);
      solutions.push_back(_particle);
      nsolutions++;
    }
  }

  if(nsolutions<=maxsolutions-maxsolutions/10){
    hasentered=false;
    firsttime=true;
  }
  //  update();

  return _flag;

}


void EFILE::add2Cluster(int _whichcluster){

  if(hasclusteredfirsttime==false)return;
  //  cout<<_whichcluster<<nsolutionsbyswarm[_whichcluster]<<endl;
  proximitymatrixindex[_whichcluster][nsolutionsbyswarm[_whichcluster]]=nsolutions;
  proximitymatrixindex[_whichcluster][nsolutionsbyswarm[_whichcluster]+1]=-1;
  nsolutionsbyswarm[_whichcluster]++;
}

int EFILE::deleteFromCluster(int _whichsolution){
  int _i;
  int _j;
  int _k;
  for(_j=0;_j<nclusters;_j++)
    for(_i=0;_i<nsolutionsbyswarm[_j];_i++)
      if(proximitymatrixindex[_j][_i]==_whichsolution){
	for(_k=_i;_k<nsolutionsbyswarm[_j];_k++){
	  proximitymatrixindex[_j][_k]=proximitymatrixindex[_j][_k+1];
	}
	proximitymatrixindex[_j][_k]=-1;
	nsolutionsbyswarm[_j]--;
	return 1;
      }
  return -1;
}

int EFILE::substractFromTo(int _from, int _to, int _quantity){
  int _i;
  int _j;
  for(_j=0;_j<nclusters;_j++){
    for(_i=0;_i<nsolutionsbyswarm[_j];_i++){
      if(proximitymatrixindex[_j][_i]>_from&&proximitymatrixindex[_j][_i]<_to){
	proximitymatrixindex[_j][_i]-=_quantity;
      }
    }
  }
  return -1;

}
int EFILE::updateClusters(vector<int> &_whichparticles){
  int _counter(0);
  if(hasclusteredfirsttime==false)return -1;
    _whichparticles.push_back(nsolutions);
    while(_whichparticles.size()>_counter+1){
      int _from(_whichparticles[_counter]);
      int _to(_whichparticles[_counter+1]);
       deleteFromCluster(_from);
       substractFromTo(_from,_to,_counter+1);
      _counter++;
    }
  
  return 1;
}
  

bool EFILE::addAll(Particle &_particle){
  bool _flag=true;
  vector<bool> erase;
  //  vector<EPSs>::iterator _iterator;

  for(int _i(0);_i<allnsolutions;_i++){
    int _tmp;
    _tmp=domine(allsolutions[_i].fx,_particle.fx);
    if(_tmp==1||_tmp==0) _flag=false;

    if(_tmp==-1){
      erase.push_back(true);
    }
    else erase.push_back(false);
  }

   vector<bool>::iterator _iterator=erase.begin();
   vector<Particle>::iterator _iterator2=allsolutions.begin();
   for(_iterator=erase.begin(); _iterator != erase.end();++_iterator) {
     if(*_iterator==true){
       allsolutions.erase(_iterator2);
       allnsolutions--;
     }
     else
       _iterator2++;
   }

  if(_flag==true){
    if(allnsolutions>maxsolutions*3)return _flag;
      allsolutions.push_back(_particle);
      allnsolutions++;
  }
  return _flag;

}


bool EFILE::reAdd(){
  bool _flag=true;
  vector<bool> erase;
  vector<int> _delparticles;
  erase.resize(nsolutions);

  //  vector<EPSs>::iterator _iterator;
  for(int _i(0);_i<nsolutions;_i++){
    erase[_i]=false;
    for(int _j(0);_j<nsolutions;_j++){
      int _tmp;
      if(_i==_j)continue;
      _tmp=domine2(solutions[_i].fx,solutions[_j].fx);

      if(_tmp==1||_tmp==0) _flag=false;
      
      if(_tmp==-1){
      _delparticles.push_back(_i);
	erase[_i]=true;
      }
    }
  }
  //  if(_delparticles.size()>0)
  // updateClusters(_delparticles);

   vector<bool>::iterator _iterator=erase.begin();
   vector<Particle>::iterator _iterator2=solutions.begin();
   for(_iterator=erase.begin(); _iterator != erase.end();++_iterator) {
     if(*_iterator==true){
       solutions.erase(_iterator2);
       nsolutions--;
     }
     else
       _iterator2++;
   }

  return _flag;

}



int EFILE::falseReAdd(){
  int _howmany(0);
  vector<bool> erase;
  erase.resize(nsolutions);

  //  vector<EPSs>::iterator _iterator;
  for(int _i(0);_i<nsolutions;_i++){
    erase[_i]=false;
    for(int _j(0);_j<nsolutions;_j++){
      int _tmp;
      if(_i==_j)continue;
      _tmp=domine2(solutions[_i].fx,solutions[_j].fx);
      if(_tmp==-1)
	erase[_i]=true;
    }
  }
   vector<bool>::iterator _iterator=erase.begin();
   vector<Particle>::iterator _iterator2=solutions.begin();
   for(_iterator=erase.begin(); _iterator != erase.end();++_iterator) {
     if(*_iterator==true){
       _howmany++;
     }
     else
       _iterator2++;
   }
  return _howmany;
}


int EFILE::domine2(vector<double> &_a,vector<double>&_b){
  vector<double> _box(nobjectives),_box2(nobjectives),_box3(nobjectives);
  bool _flag=true;
  //calculate the box of both particles
  for (int _i = 0; _i < nobjectives; _i++){
    _box[_i] = (int) floor ((fabs(tlb[_i]-_a[_i]) / EPS[_i]));
    _box2[_i] = (int)floor ((fabs(tlb[_i]-_b[_i]) / EPS[_i]));
    //

    //_box[_i] = (int) floor ((_a[_i] / EPS[_i]));
    //_box2[_i] = (int)floor ((_b[_i] / EPS[_i]));
    //_box3[_i] = (_box[_i]<_box2[_i])?_box[_i]*EPS[_i]:_box2[_i]*EPS[_i];//
    _box3[_i] = (int)_box[_i]*EPS[_i];
    //if they are in the same box
    if(_box[_i]!=_box2[_i])_flag=false;
  }
  if(_flag==true){//check for dominance
    int anterior = 0, mejor;

    for(int _i=0;_i<nobjectives;_i++){
      if(_a[_i] <_b[_i])	mejor = 1;
      else if(_b[_i]<_a[_i])mejor = -1;
      else mejor = 0;
      if(mejor!=anterior&&anterior!=0&&mejor!=0){
	if(euclideanDistance(_a,_box3)<euclideanDistance(_b,_box3))
	  return 1;
	else return -1;	}
      if(mejor!=0) anterior = mejor;
    }
    //      if(anterior==1) return true;
    //else return false;
    return(anterior);

  }
  int anterior = 0, mejor;
  for(int _i=0;_i<nobjectives;_i++){
    if(_box[_i] <_box2[_i])	mejor = 1;
    else if(_box2[_i]<_box[_i])mejor = -1;
    else mejor = 0;
    if(mejor!=anterior&&anterior!=0&&mejor!=0)return 11;
    if(mejor!=0) anterior = mejor;
  }
  return(anterior);


}

void EFILE::normalizeDistances2(){

  for(int _j(0);_j<nsolutions;_j++){
    for(int _i(0);_i<nobjectives;_i++)
      {
	if(solutions[_j].fx[_i] < tlb[_i]) tlb[_i]=solutions[_j].fx[_i];
	if(solutions[_j].fx[_i] > tub[_i]) tub[_i]=solutions[_j].fx[_i];

      }
  }

  double min;
  int _index;
  int _ncurrentsolutions=nsolutions;
  int _a1(0);
  int _a2(0);
  while(_ncurrentsolutions>maxsolutions+maxsolutions/20||_ncurrentsolutions<maxsolutions-maxsolutions/10){
    _ncurrentsolutions=nsolutions-falseReAdd();

    if(_ncurrentsolutions<maxsolutions-maxsolutions/10){
      for(int _i(0);_i<nobjectives;_i++){
	EPS[_i]/=1.2;
      }
	if(_a1==2&&_a2==1) break;
	_a2=_a1;
	_a1=1;

    }
    else if(_ncurrentsolutions>maxsolutions+maxsolutions/20){
      for(int _i(0);_i<nobjectives;_i++){
	EPS[_i]*=1.2;
      }
	if(_a1==1&&_a2==2) break;
	_a2=_a1;
	_a1=2;
    }


  }
  reAdd();

}


void EFILE::normalizeDistances1(){

  for(int _j(0);_j<nsolutions;_j++){
    for(int _i(0);_i<nobjectives;_i++)
      {
	if(solutions[_j].fx[_i] < tlb[_i]) tlb[_i]=solutions[_j].fx[_i];
	if(solutions[_j].fx[_i] > tub[_i]) tub[_i]=solutions[_j].fx[_i];

      }
  }
  for(int _i(0);_i<nobjectives;_i++){
    EPS[_i]=(double)(tub[_i]-tlb[_i])/nsolutions;
  }

  double min;
  int _index;
  int _a1(0),_a2(0);
  int _ncurrentsolutions=nsolutions;

  while(_ncurrentsolutions>maxsolutions+maxsolutions/20||_ncurrentsolutions<maxsolutions-maxsolutions/10){
    _ncurrentsolutions=nsolutions-falseReAdd();

    if(_ncurrentsolutions<maxsolutions-maxsolutions/10){
      for(int _i(0);_i<nobjectives;_i++){
	EPS[_i]/=1.2;
      }
	if(_a1==2&&_a2==1) break;
	_a2=_a1;
	_a1=1;
    }
    else if(_ncurrentsolutions>maxsolutions+maxsolutions/20){
      for(int _i(0);_i<nobjectives;_i++){
	EPS[_i]*=1.2;
      }
	if(_a1==1&&_a2==2) break;
	_a2=_a1;
	_a1=2;
    }

  }
  reAdd();
}






void EFILE::deleteExcedent(){

  for(int _j(0);_j<nsolutions;_j++){
    for(int _i(0);_i<nobjectives;_i++)
      {
	if(solutions[_j].fx[_i] < tlb[_i]) tlb[_i]=solutions[_j].fx[_i];
	if(solutions[_j].fx[_i] > tub[_i]) tub[_i]=solutions[_j].fx[_i];

      }
  }

  vector<double> distances;
  vector<int> _indexes;
  vector<double> distances2;
  vector<int> _indexes2
;
  while(nsolutions>maxsolutions){
    
    _indexes.resize(nsolutions);

    distances.resize(nsolutions);
    _indexes2.resize(nsolutions);

    distances2.resize(nsolutions);

    for(int _j(0);_j<nsolutions;_j++){
      distances[_j]=10.0*pow(10.0,10.0);
      for(int _k(0);_k<nsolutions;_k++){
	if(_j==_k)continue;
	double _sum(0);
	for(int _i(0);_i<nobjectives;_i++)
	  {
	    _sum+=pow(solutions[_j].fx[_i]-solutions[_k].fx[_i],2.0);
	  }
	double _tot=sqrt(_sum);

	if(_tot<distances[_j]){
	  distances2[_j]=distances[_j];
	  distances[_j]=_tot;
	  _indexes2[_j]=_indexes[_j];
	  _indexes[_j]=_k;
	}
      }
    }
    
  double min;
  int _index;
  min=10.0*pow(10.0,10.0);
  for(int _j(0);_j<nsolutions;_j++){
    if(distances[_j]+distances2[_j]<min){
      min=distances[_j]+distances2[_j];
      _index=_j;
    }
  }

   vector<Particle>::iterator _iterator2=solutions.begin();
   _iterator2+=_index;
   solutions.erase(_iterator2);
   nsolutions--;
  }
}


void EFILE::finalSolutions(){
  for(int _i(0);_i<allnsolutions;_i++){
    add(allsolutions[_i]);
  }
  //cout<<"deleteExcedent"<<endl;
  deleteExcedent();
}

double EFILE::euclideanDistance(vector<double> &_v1, vector<double> & _v2){
  double s(0);
  vector<double>::iterator _iterator1=_v1.begin();
  vector<double>::iterator _iterator2=_v2.begin();
  for(_iterator1=_v1.begin(); _iterator1 != _v1.end();++_iterator1) {
    s+= pow(*_iterator2-*_iterator1,2.0);
  }
  return sqrt(s);    
}


int EFILE::nSolutions(){
  return nsolutions;
}

int EFILE::selectRandomSolution(int _whichcluster){
    return (int) rnd(0,nsolutions);
}

int EFILE::selectClusteredRandomSolution(int _whichcluster){
  if(_whichcluster>nclusters) _whichcluster=(int) rnd(0,nclusters);//ojo hay que verificar
  if(nsolutionsbyswarm[_whichcluster]==0){
    return(int) rnd(0,nsolutions);
  }
  int _tmp=(int )rnd(0,nsolutionsbyswarm[_whichcluster]);

  return proximitymatrixindex[_whichcluster][_tmp];
}

int EFILE::nClusteredSolutions(int _whichcluster){
  return nsolutionsbyswarm[_whichcluster];
}
int EFILE::selectClusteredSolution(int _whichcluster,int _whichsolution){
  return proximitymatrixindex[_whichcluster][_whichsolution];
}




double EFILE::rnd(double _min,double _max){
  return((double)(_min + ((double)(_max-_min)*rand()/(double)(RAND_MAX+_min))));
}

void EFILE::output(){
  finalSolutions();
  printSolutions();
}