psomatrixcircuit.c

用于逻辑电路设计的PSO算法代码,代码简单明了

		reservaMemoriaParticula(&bestIndividualExp[i],1);
		reservaMemoriaParticula(&bestSocialExp[i],1);
	}
	
	/*Reserva memoria para almacenar a la mejor y a la peor particula de la generacion*/
	reservaMemoriaParticula(&(Gen.mejor),1);
	reservaMemoriaParticula(&(Gen.peor),1);

	/*Reserva memoria para almacenar a la mejor y a la peor particula de la corrida*/
	reservaMemoriaParticula(&(Corr.mejor),1);
	reservaMemoriaParticula(&(Corr.peor),1);

	/*Memoria necesaria para el manejo de las matrices*/
	reservaMemoriaMatriz();

}

/*Reserva memoria para los elementos de la particula*/
void reservaMemoriaParticula(particula *par, unsigned rec)
{
	par->vi = memVi;
	par->cromX = memCromX;
}


/*Libera toda la memoria reservada a lo largo del programa una vez terminadas las corridas*/
void liberaMemoria(void)
{
	unsigned i;

	/*Libera la memoria reservada para la tabla de verdad*/
	liberaMemoriaTT();

	/*Libera la memoria de cada particula en las poblaciones*/
	for(i=0; i<tPob; i++){
		liberaMemoriaParticula(&poblacion[i],0);
		liberaMemoriaParticula(&bestSocialExp[i],1);
		liberaMemoriaParticula(&bestIndividualExp[i],1);
	}

	/*Libera la memoria de las poblaciones*/
	free(poblacion);
	free(bestSocialExp);
	free(bestIndividualExp);

	/*Libera la memoria de la mejor y de la peor particula de la generacion*/
	liberaMemoriaParticula(&(Gen.mejor),1);
	liberaMemoriaParticula(&(Gen.peor),1);

	/*Reserva memoria para almacenar a la mejor y a la peor particula de la corrida*/
	liberaMemoriaParticula(&(Corr.mejor),1);
	liberaMemoriaParticula(&(Corr.peor),1);

	/*Libera la memoria asociada a las variables*/
	free(lInf);
	free(lSup);
	free(bitVariable);

	/*Libera la memoria usada para el manejo de las matrices*/
	reservaMemoriaMatriz();
}

/*Libera la memoria reservada para cada part韈ula*/
void liberaMemoriaParticula(particula *par, unsigned rec)
{
	free(par->vi);
	free(par->cromX);
}

/*Programa principal del Particle Swarm*/
void pSwarm(unsigned corr)
{
	unsigned gen, semilla = initrandom(0);
	char nfileGen[sizeNameFile];

	nameFileCorr(corr,nfileGen);		/*Obtiene el nombre del archivo de estadisticas de la corrida*/
	poblacionInicial();					/*Poblacion inicial de la corrida*/
	estEncCorr(nfileGen,semilla);		/*Encabezado de la estadistica de la corrida*/
	for(gen=0; gen<nGen; gen++){
		iniEstadistica(&Gen);			/*Se inicializa la informaci髇 para la estad韘tica de la generacion*/
		aptitudPoblacion(gen);			/*Calcula los datos de cada particula*/
		//mutacion();
		//iniEstadistica(&Gen);			/*Se inicializa la informaci髇 para la estad韘tica de la generacion*/
		//aptitudPoblacion(gen);		/*Calcula los datos de cada particula*/
		infoCorrida(nfileGen,gen);		/*Datos que se obtuvieron en la generacion*/
		algoritmoPSO(gen);				/*Algoritmo principal*/
		mutacion();
	}
	estPieCorr(nfileGen);				/*Resultados finales de la corrida*/
}

/*Genera el nombre del archivo para la estadistica de la corrida actual*/
void nameFileCorr(unsigned corr, char *nombre)
{
	char num[10];

	strcpy(nombre,nfGen);
	dtoa(corr,0,num);
	strcat(nombre,corr == 0 ? "0" : num);
	strcat(nombre,".csv");
}

/*Genera la poblacion aleatoria inicial de individuos*/
void poblacionInicial(void)
{
	unsigned i,j; 

	for(i=0; i<tPob; i++)
		for(j=0; j<nAlelo; j++)
			poblacion[i].cromX[j] = representacion == BINARIA ? flip(0.5) : rndIR(lInf[j],(lSup[j]+1)*cardinalidad)%(lSup[j]+1);
}

/*Calcula las caracteristicas de cada particula*/
void aptitudPoblacion(unsigned gen)
{
	unsigned i,j;
	int par, par0, par1;

	for(i=0; i<tPob; i++){
		/*Obtiene la aptitud de la particula*/
		aptitudParticula(&poblacion[i]);

		/*Busca a la mejor particula local que se ha encontrado para cada particula*/
		if(gen == 0 || poblacion[i].aptitud > bestIndividualExp[i].aptitud)
			copiaParticula(poblacion[i],&(bestIndividualExp[i]));
	}

	for(i=0; i<tPob; i++){
		/*Busca a la mejor part韈ula que se ha encontrado en el vecindario de la particula*/
		par = par0 = par1 = i;
		for(j=0; j<tVec; j+=2){
			par0 = par0 + 1 < (int)tPob ? par0 + 1 : 0;
			par1 = par1 - 1 < 0 ? (int)tPob - 1 : par1 - 1;
			if(bestIndividualExp[par0].aptitud > bestIndividualExp[par].aptitud ) par = par0;
			if(bestIndividualExp[par1].aptitud > bestIndividualExp[par].aptitud ) par = par1;
		}
		copiaParticula(bestIndividualExp[par],&bestSocialExp[i]);

		/*Se calculan los datos para las estadisticas de la generacion*/
		Gen.mediaAptitud += bestSocialExp[i].aptitud/tPob;
		Gen.cuadradosAptitud += pow(bestSocialExp[i].aptitud,2)/tPob;

	   /*Se almacena a la mejor y a la peor particula de la generacion*/
		if(i == 0){
			copiaParticula(bestSocialExp[i],&(Gen.mejor));
			copiaParticula(bestSocialExp[i],&(Gen.peor));
		}
		else{
			if(bestSocialExp[i].aptitud > Gen.mejor.aptitud)
				copiaParticula(bestSocialExp[i],&(Gen.mejor));
			if(bestSocialExp[i].aptitud < Gen.peor.aptitud)
				copiaParticula(bestSocialExp[i],&(Gen.peor));
		}
	}
}

/*Obtiene la aptitud de la part韈ula*/
void aptitudParticula(particula *par)
{
	/*Se evalua la matriz y se obtienen el n鷐ero de salidas iguales y el n鷐ero de WIRE's*/	
	evalua(par->cromX, &(par->numIgual));

	/*Pone a cero la variable que cuenta el numero de WIRE's*/
	par->numNoGates = 0;

	/*Si existen violaciones*/
	if(par->numIgual >= numTSalidas){
		/*Hay que contar el numero total de compuertas que estan en la solucion
		y restarlo del numero total de compuertas en la matriz, es decir, tomar 
		a todos los no involucrados como WIRE's*/
		par->numGates = cuentaCompuertas();
		par->numNoGates = tMat - par->numGates;
	}
	par->aptitud = (double)(par->numIgual + par->numNoGates);
}

/*Copia los datos de la particula in en out*/
void copiaParticula(particula in,particula *out)
{
	unsigned i;
	
	out->numGates = in.numGates;
	out->numIgual = in.numIgual;
	out->numNoGates = in.numNoGates;
	out->aptitud = in.aptitud;
	
	/*Copia el cromosoma y las velocidades de cada alelo en el cromosoma*/
	for(i=0; i<nAlelo; i++){
		out->cromX[i] = in.cromX[i];
		out->vi[i] = in.vi[i];  
	}
}


void mutacion(void)
{
	unsigned i, j, flag = 0;

	for(i=0; i<tPob; i++)
		//if(poblacion[i].aptitud <= bestSocialExp[i].aptitud )
			for(j=0; j<nAlelo; j++){
				if(flip(pMut)){
					switch(representacion){
						case BINARIA:
							poblacion[i].cromX[j] = poblacion[i].cromX[j] ? 0 : 1;
							break;
						case ENTERAA:
						case ENTERAB:
							poblacion[i].cromX[j] = rndIR(lInf[j],(lSup[j]+1)*cardinalidad)%(lSup[j]+1);
							break;
					}
				}
			}
				
}

/*Se calculan los datos para las estadisticas de la corrida*/
void infoCorrida(char *nfile, unsigned gen)
{	
	/*Calcula la media y los datos de la varianza*/
	Corr.mediaAptitud += Gen.mediaAptitud/nGen;
	Corr.cuadradosAptitud += Gen.cuadradosAptitud/nGen;

	/*Se almacena el mejor y el peor individuo de la corrida*/
	if(gen == 0){
		copiaParticula(Gen.mejor,&(Corr.mejor));
		copiaParticula(Gen.peor,&(Corr.peor));
		/*Si se encontr