malla-adaptativa.cpp

moga2

#include "moga2.h"//malla-adaptativa.h"
MallaAdap::MallaAdap(int nobj,int tampareto,int _bits){

  nObjs=nobj;
  tamPARETO=tampareto;
  nDivs=15;
  posPARETO=0;
  hipercubosUtilizadosVar=0;
  iTot=0;
  restPobNRem=0;
  restPobNRemb=false;
  restableceMemoriaVar=false;
  bits=_bits;
  sndElit=0;
  NG=1000000000;
  tamDiv=new(double[nObjs]);
  inicioMalla=new(double[nObjs]);
  lMalla=(long)floor(pow(nDivs,nObjs));
  hipercubo=new(long[lMalla]);
  PARETO=new(Individuo[tamPARETO]);
  
  for(int i=0;i<tamPARETO;i++){
    PARETO[i].genotipo=inicializa();
    PARETO[i].aptObj=new (double[nObjs]);
    PARETO[i].loc=0;
    //    PARETO[i].aptFake=-1;
  }
}
/*
 Metodo que copia un arreglo de enteros (genotipo) hacia memoria y regresa un puntero hacia ese espacio de memoria 
*/

void MallaAdap::copia(int *num,int *num2,int n)
{
  int *pnum=num;
  for(int i=0;i<n;i++,pnum++,num2++)//recorre todo el genotipo,haciendo
    *pnum=*num2;//una copia hacia la memoria creada.
}

void MallaAdap::copia(double *num,double *num2,int n)
{
  double *pnum=num;
  for(int i=0;i<n;i++,pnum++,num2++)//recorre todo el genotipo,haciendo
    *pnum=*num2;//una copia hacia la memoria creada.
}


/*
  metodo que genera un genotipo con la seleccion del valor de los alelos al azar con probabilidad de 0.5
*/
int *MallaAdap::inicializa(){
  int *gtemp,*genotipo;
  genotipo=new(int[bits]);//asigna memoria hacia el genotipo a generar
  gtemp=genotipo;
  for(int i=0;i<bits;i++,gtemp++)//genera el genotipo, alelo a alelo,mediante
    *gtemp=0;//probabilidad.
  return genotipo;//regresa el genotipo generado
}


int MallaAdap::Domina(Individuo *I1,Individuo *I2){
  int anterior = 0;
  int mejor;
  double *ind1=I1->aptObj;
  double *ind2=I2->aptObj;

  
    int a=restricciones(I1->genotipo);
    int b=restricciones(I2->genotipo);
    if(a<b)//el primero domina
      return 1;
    else if(b<a)//el segundo domina
      return -1;
  for(int i=0;i<nObjs;i++,ind1++,ind2++){
    if(*ind1 <*ind2)	mejor = 1;
    else if(*ind2<*ind1)mejor = -1;
    else mejor = 0;
    if(mejor!=anterior&&anterior!=0&&mejor!=0) return(11);
    if(mejor!=0) anterior = mejor;
  }
  return(anterior);
  
}
/*
Metodo que guarda a un individuo en la memoria perteneciente al fretnte de pareto..
 */
void MallaAdap::gPARETO(Individuo *ind)
{
  copiaxxx(PARETO+posPARETO,ind);
  posPARETO++;
}

/*
metodo que checa si un individuo domina a almenos uno de ma memoria del frente de pareto, si es asi entonces reemplaza al primer individuo dominado, y elimina a los individuos dominados de la memoria.
 */
int MallaAdap::dominaAPareto(Individuo *ind){
  int resultado=0,i=0,j=0,dom=0;
  int *dominados=new(int[posPARETO]);
  int cual=-1;
  while((i < posPARETO)&&(resultado!=-1)){
    resultado = Domina(ind, PARETO+i);
    if(resultado==-1||resultado==0){dom=-1;break;}
    dominados[i]=0;
    if (resultado == 1){
      if(dom==0){// si domina el nuevo individuo al archivo
	iTot=0;
	restPobNRem=0;
	if(restPobNRemb==true){restPobNRemb=false;restableceMemoriaVar=true;};
	cual=i;
	if(posPARETO>=tamPARETO){
	  if(hipercubo[PARETO[cual].loc]==1)hipercubosUtilizadosVar--;
	  hipercubo[PARETO[cual].loc]--;
	}
	copiaxxx(PARETO+cual,ind);
	if(posPARETO==tamPARETO)
	  ind->loc=cualLoc(ind);
	else ind->loc=0;
	if(ind->loc==-1)
	  actualizaLoc();
	else
	  PARETO[cual].loc=ind->loc;
	if(hipercubo[PARETO[cual].loc]==0) hipercubosUtilizadosVar++;
	hipercubo[PARETO[cual].loc]++;

      }
      else dominados[i]=1;
      dom ++;
    }
    i++;
  }
  if(dom>1){
    eliminaDominados(dominados);
    hipercubosUtilizadosVar=0;
  }
  delete [] dominados;
  return dom;
}
  
/*
Funcion que elimina a los individuos dominados.
 */
void MallaAdap::eliminaDominados(int *dominados){
  long i = 0;
  long pospareto=posPARETO;
  int *pareto=new(int[bits*posPARETO]);
  double *objs=new(double[nObjs*posPARETO]);

  for (i = 0; i < posPARETO; i++){
    copia(pareto+(i*bits), PARETO[i].genotipo,bits);
    copia(objs+(i*nObjs),PARETO[i].aptObj,nObjs);
  }
  posPARETO = 0;
  for (i = 0; i < pospareto; i++){
    if (dominados[i]!=1){
      copia(PARETO[posPARETO].genotipo,pareto+(i*bits),bits);
      copia(PARETO[posPARETO].aptObj,objs+(i*nObjs),nObjs);
      PARETO[posPARETO].loc=0;
      posPARETO++;
    }
  }
  delete [] pareto;
  delete [] objs;
}

void MallaAdap::copiaxxx(Individuo *ind,Individuo *ind2){
  copia(ind->genotipo,ind2->genotipo,bits);
  copia(ind->aptObj,ind2->aptObj,nObjs);
  ind->loc=ind2->loc;
}  

void  MallaAdap::actualizaLoc(){
  double *MAptObj=new(double[nObjs]);
  double *mAptObj=new(double[nObjs]);

  for(int i=0;i<nObjs;i++){
    MAptObj[i]=-NG;
    mAptObj[i]=NG;
  }
  inicializaDivisiones();
  for(int i=0;i<nObjs;i++){
    for(int j(0);j<posPARETO;j++){
      if(mAptObj[i]>PARETO[j].aptObj[i]) mAptObj[i]=PARETO[j].aptObj[i]; //busca la menor aptitud
      if(MAptObj[i]<PARETO[j].aptObj[i]) MAptObj[i]=PARETO[j].aptObj[i]; //busca la mayor aptitud.
    }
    tamDiv[i]=(MAptObj[i]-mAptObj[i])/(nDivs-1); //encuentra el rango para la grid
    inicioMalla[i]=mAptObj[i]-(tamDiv[i]/2);//coloca el punto de partida de la hipercubo
  }
  for(long i(0);i<posPARETO;i++){
    PARETO[i].loc=cualLoc(PARETO+i);
    hipercubo[PARETO[i].loc]++;
  }
  delete [] mAptObj;
  delete [] MAptObj;
}

void MallaAdap::inicializaDivisiones(){
  for(long i(0);i<lMalla;i++)
    hipercubo[i]=0;
}

/*
Asigna una localidad 
 */
long MallaAdap::cualLoc(Individuo *ind){
  long temp;
  long loc=0;
  int i=nObjs-1;
  for(int j(0);j<nObjs;j++,i--){
    temp= (long )floor((ind->aptObj[j]-inicioMalla[j])/tamDiv[j]);
    if(temp>nDivs||temp<0) return -1;
    loc+=(long )floor(temp*pow(nDivs,i));
  }
  return loc;
}


void MallaAdap::FunPARETO(Individuo *ind){
  long mPoblado;
  long r;
    sndElit++;

    //  if(restricciones(ind->genotipo)>0)return; //si viola las restricciones se elimina
  restPobNRem++;

  if(posPARETO==0){ //si es el primer elemento se acepta

    gPARETO(ind);
    hipercubosUtilizadosVar=0;
    return;
  }


  if(dominaAPareto(ind)==0){//nadie domina al individuo ind
    if(posPARETO+1<tamPARETO){ //si hay espacio
      gPARETO(ind);
      hipercubosUtilizadosVar=0;
    }
    else if(posPARETO+1 == tamPARETO){//si se acaba de llenar la malla
      gPARETO(ind);
      actualizaLoc();
      hipercubosUtilizadosVar=hipercubosUtilizados();
    }
    else {// si hay que decidir
      mPoblado=buscaMasPoblado();//retorna el indice del hipercubo m'as poblado 
      r=cualLoc(ind);
      if(r==-1){//se sale de la malla y hay que rehacerla
        restPobNRem=0;
	long i=buscaIndConLoc(mPoblado);
	if(i==-1) {cout<<mPoblado<<" aqui se sale\n";exit(0);}
	copiaxxx(PARETO+i,ind);
	actualizaLoc();
	hipercubosUtilizadosVar=hipercubosUtilizados();
	iTot=0;
      }
      else if(masPoblado(mPoblado,r)){ //busca un m'as poblado
	long i=buscaIndConLoc(mPoblado);
	if(i==-1) {
	  cout<<mPoblado<<" "<<i<<" "<<hipercubo[mPoblado]<<"\n";
	  cout<<"aqui se sale2\n";exit(0);
	}
	ind->loc=r;
	copiaxxx(PARETO+i,ind);
	if(hipercubo[mPoblado] <=1 && hipercubo[r] >= 1)hipercubosUtilizadosVar--;
	hipercubo[mPoblado]--;
	hipercubo[r]++;

      }
    }
  }
  
} 

int MallaAdap::masPoblado(long mPoblado,long r){
  if(mPoblado==r)return 1;
  if(hipercubo[mPoblado]<hipercubo[r]+1)return 0;
  return 1; 
}

long MallaAdap::hipercubosUtilizados(){
  long counter(0);
  for(long i(0);i<lMalla;i++)
    if(hipercubo[i]>0)counter++;
  return counter;
}
long MallaAdap::buscaMasPoblado(){
  long mP[2]={-1,-1};
  for(long i(0);i<lMalla;i++){
    if(mP[1]<hipercubo[i]){
      mP[0]=i;
      mP[1]=hipercubo[i];
    }
  }    
  return mP[0];
}

long MallaAdap::buscaIndConLoc(long mp){
  long i;
  for(i=0;i<posPARETO;i++)
    if(PARETO[i].loc==mp)return i;
  //  for(i=0;i<posPARETO;i++)
  //cout<<PARETO[i-1].loc<<endl;
  return -1;
}

void MallaAdap::ImprimeValores(){
  for(long i=0;i<posPARETO;i++){
    for(int j=0;j<nObjs;j++)
      cout<<PARETO[i].aptObj[j]<<" ";
    cout<<endl;
  }
}