Tercera implementación del Algoritmo Genético
La segunda implementación se conserva por razones históricas, porque esta tercera sobrepasa a la anterior ampliamente:
1. El algoritmo genético es más rápido.
2. Concepto de población.
3. Manejo de entradas y salidas de tipo float
4. Manejo de funciones como seno, coseno, tangente, valor absoluto,
exponencial, raíz cuadrada en las instrucciones de los algoritmos generados.
5. Los algoritmos generados pueden ser compilados y ejecutados directamente
en un compilador de C.
6. Manejo dinámico de memoria.
7. Fuerte documentación del código.
8. Manejo de probabilidades en instrucciones de tipo matemático, función y
si condicionales.
El algoritmo de inicialización se llama Pobl03.ini y este es su contenido
NUMORGANISMOS=40; //Cuantos organismos tendrá el
ambiente al tiempo
PROBABLEBASICO=60; //Probabilidad de que la instrucción sea una operación
básica: suma, resta, multiplicación, división
PROBABLEFUNCION=20; //Probabilidad de que la instrucción sea una función:
seno, coseno, tangente, valor absoluto,
MAXINSTRUCCIONES=30; //El maximo son 256 instrucciones
NUMVARIABLES=5; //Total variables que tendrá cada algoritmo genético
TOTALSIMULACION=80000; //Cuantos organismos va a generar
MAXIMOINTERPRETA=400; //Cuantas instrucciones del algoritmo genetico
ejecutará.
ENTRADAS=25; //Numero de entradas/salidas que tendrá
MAXTOLERANCIA=5000; //Si la adaptacón del organismo comparado con este valor
es menor entonces es evaluado para selección
sEntrada=1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,;
sSalidas=2,3,5,7,11,13,17,19,23,29,31,37,41,43,47,53,59,61,67,71,73,79,83,89,97,;
Una muestra de los resultados
Poblacion 03: Mejora uso de poblaciones
Autor: Rafael Alberto Moreno Parra
Fecha: 01 de Enero de 2007
E-mail: enginelife@hotmail.com
http://darwin.50webs.com
Entradas son: 1.000000, 2.000000, 3.000000, 4.000000, 5.000000, 6.000000,
7.000000, 8.000000, 9.000000, 10.000000, 11.000000, 12.000000, 13.000000,
14.000000, 15.000000, 16.000000, 17.000000, 18.000000, 19.000000, 20.000000,
21.000000, 22.000000, 23.000000, 24.000000, 25.000000,
Salidas son: 2.000000, 3.000000, 5.000000, 7.000000, 11.000000, 13.000000,
17.000000, 19.000000, 23.000000, 29.000000, 31.000000, 37.000000, 41.000000,
43.000000, 47.000000, 53.000000, 59.000000, 61.000000, 67.000000, 71.000000,
73.000000, 79.000000, 83.000000, 89.000000, 97.000000,
// Organismo=1 se adapta=26.707367
#include <stdio.h>
#include <math.h>
void main(void);
void main()
{
float V0=0, V1=0, V2=0, V3=0, V4=0;
float fError=0, fEntrada[25], fSalida[25];
fEntrada[0]=1.000000;
fEntrada[1]=2.000000;
fEntrada[2]=3.000000;
fEntrada[3]=4.000000;
fEntrada[4]=5.000000;
fEntrada[5]=6.000000;
fEntrada[6]=7.000000;
fEntrada[7]=8.000000;
fEntrada[8]=9.000000;
fEntrada[9]=10.000000;
fEntrada[10]=11.000000;
fEntrada[11]=12.000000;
fEntrada[12]=13.000000;
fEntrada[13]=14.000000;
fEntrada[14]=15.000000;
fEntrada[15]=16.000000;
fEntrada[16]=17.000000;
fEntrada[17]=18.000000;
fEntrada[18]=19.000000;
fEntrada[19]=20.000000;
fEntrada[20]=21.000000;
fEntrada[21]=22.000000;
fEntrada[22]=23.000000;
fEntrada[23]=24.000000;
fEntrada[24]=25.000000;
fSalida[0]=2.000000;
fSalida[1]=3.000000;
fSalida[2]=5.000000;
fSalida[3]=7.000000;
fSalida[4]=11.000000;
fSalida[5]=13.000000;
fSalida[6]=17.000000;
fSalida[7]=19.000000;
fSalida[8]=23.000000;
fSalida[9]=29.000000;
fSalida[10]=31.000000;
fSalida[11]=37.000000;
fSalida[12]=41.000000;
fSalida[13]=43.000000;
fSalida[14]=47.000000;
fSalida[15]=53.000000;
fSalida[16]=59.000000;
fSalida[17]=61.000000;
fSalida[18]=67.000000;
fSalida[19]=71.000000;
fSalida[20]=73.000000;
fSalida[21]=79.000000;
fSalida[22]=83.000000;
fSalida[23]=89.000000;
fSalida[24]=97.000000;
for (int iCont=0; iCont<25; iCont++)
{
V0=fEntrada[iCont];
V1=0;
V2=0;
V3=0;
V4=0;
//Codigo generado por el algoritmo genetico
a0: V2 = sin(V0);
a1: V2 = exp(V2);
a2: V3 = V2 + V0;
a3: V2 = sqrt(V3);
a4: V1 = cos(V2);
a5: V3 = V0 - V1;
a6: if (V2 > V0) goto a28;
a7: V2 = sqrt(V3);
a8: V0 = V1 * V2;
a9: V2 = V3 * V2;
a10: if (V2 != V3) goto a27;
a11: V0 = V1 - V1;
a12: V2 = V2 / V3;
a13: V0 = V3 + V0;
a14: V0 = V2 - V1;
a15: V3 = sin(V2);
a16: V0 = V3 / V3;
a17: V2 = V0 / V3;
a18: V1 = V0 + V0;
a19: V2 = tan(V0);
a20: V2 = V0 + V0;
a21: V2 = V0 * V2;
a22: V1 = V1 - V1;
a23: V0 = V1 - V1;
a24: if (V3 > V0) goto a28;
a25: V0 = sqrt(V1);
a26: V2 = V3 / V3;
a27: V1 = V3 + V0;
a28: V3 = abs(V2);
a29: V1 = V3 - V1;
//Fin del codigo
float fDiferencia = fSalida[iCont]-V1;
if (fDiferencia<0) fError -= fDiferencia;
else fError += fDiferencia;
}
printf("Adaptacion: %f", fError);
}
El algoritmo generado puede ser compilado en C.