Esta implementación se diferencia de la anterior porque los hijos de un padre deben ser mejores en la adaptación que el padre mismo. Si el desempeño es igual simplemente se eliminan. De resto tiene las mismas características:
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
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.