Por: Alirio Adolfo Tacoa Morales Freddy De Jesus Perez T. Librerias Standar
include <stdlib.h>
include <stdio.h>
include <conio.h>
include <math.h>
include <graphics.h>
include <iostream.h>
include <dos.h>
Declaracion De Constantes
const MaxGenes = 16;
const NroHijos = 2; Hijos en la Decendencia
const float LimInf = 0.0;
const float LimSup = 2.0;
const float Base = 10.0;
const float Constante = 65535.0;
const int Maximo = 100;
float Promedio[Maximo];
float MejorAdap[Maximo];
float ProbMutacion1[Maximo];
float ProbMutacion2[Maximo];
float ProbMutacion3[Maximo];
float ProbCruce1[Maximo];
float ProbCruce2[Maximo];
float ProbCruce3[Maximo];
Declaracion de Variables Globales
extern int xAct;
int y2, xAct=4;
char Ch;
float NroGeneraciones,NroIndividuos,ProbCruce,ProbMutacion;
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
float Calcular_Maximo( void )
{
float MaximoFx = 0.0;
float X;
float Valor, Fx;
for ( X = 1; X <= 65535; X++)
{
Valor = LimInf-(X*((LimInf-LimSup)/Constante));
Fx = pow(Valor*sin(Base*M_PI*Valor),2)+1;
if (Fx >= MaximoFx)
{ MaximoFx = Fx;}
} for
return MaximoFx;
} Calcular Maximo
- - - - - - - - - - - - - - - Pantalla - - - - - - - - - - - - - - - - - -
class Pantalla{
public:
Pantalla(char Ruta[15]);
void Cerrar(); Modo Grafico
void MenuHorizontal();
int OpcionHorizontal(int Op);
void Acercade();
int FormatoGrafica(int NroGeneraciones,int Opcion);
void Mensaje ( char Mensaje[30] );
char Botoncitos(int fila1, int col1, int fila2, int col2);
void Botoncito(int x, int y);
char Salir(void);
float Captura(int X1, int Y1);
void AbrirVentana(int X1, int Y1, int X2, int Y2);
void CerrarVentana( int X1, int Y1, int X2, int Y2, int Estilo, int Color);
void Grafica1(int NroGeneraciones, int Cuantos);
void Grafica2(int NroGeneraciones, int Cuantos);
void Grafica3(int NroGeneraciones, int Cuantos);
};
- - - - - - - - - - - - - - - Individuo - - - - - - - - - - - - - - - - -
class Individuo{
private:
float ValorReal; Entre 0 y 2
float Adaptabilidad;
unsigned int Acumulador;
int Cromosoma[MaxGenes];
void RealWritexy( int X, int Y, float Numero );
protected:
int Gen;
float Aleatorio(float Minimo, float Maximo);
public:
Individuo(); Constructor
void Mutar(float ProbMutacion);
float Adaptacion (float MaximoFx);
void Mostrar(int Linea);
void Conversion();
void Decodificar();
void InsertarGen(int Valor, int Gen);
int SacarGen(int Gen);
}; Individuo
- - - - - - - - - - - - - - - Generacion - - - - - - - - - - - - - - - -
class Generacion:public Individuo{
private:
Individuo *Poblacion; Arreglo Dinamico
Individuo Decendencia[NroHijos];
Individuo SuperIndiv;
float TotalAdaptacion;
int Indiv;
public:
Generacion(int NumIndividuos); Constructor
void Reproducir(float ProbCruce,int Padre1, int Padre2);
void CalcularAdaptacion(float MaximoFx,int NroIndividuos);
int Seleccionar(float MaximoFx, int NroIndividuos);
Individuo Hijo1();
Individuo Hijo2();
void Agregar_Individuo(Individuo Decendencia[NroHijos], int NroIndividuos );
Individuo SuperIndividuo(int NroIndividuos,float MaximoFx);
void Mostrar(int NumIndividuos, float MaximoFx,int Generacion);
void Generacion::Ordenar(int NumIndividuos, float MaximoFx);
float PromedioAdaptabilidad(int NumIndividuos);
void Liberar();
}; Poblacion
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void Obtener_Solucion(Pantalla Monitor)
{
Monitor.AbrirVentana(10,50,630,450);
setcolor(BLACK);255
settextstyle(TRIPLEX_FONT, HORIZ_DIR, 3);
outtextxy(180,70,"Algoritmo Genetico Simple");
settextstyle(0, 0, 1);
setcolor(YELLOW);
outtextxy(80,110,"Max F(x) = (xsen(10*Pi*x))^2+1 entre [0 y 2] es =");
int AP, AP2;
float MaximoFx = Calcular_Maximo();
outtextxy(500,110,"4.803513");
setcolor(12);
line (14,420,625,420);
randomize();
Generacion Gener_Anterior(NroIndividuos);
Generacion Gener_Siguiente(NroIndividuos);
Individuo Decendencia[NroHijos];
Individuo Superman;
Gener_Anterior.Ordenar(NroIndividuos,MaximoFx);
Gener_Anterior.Mostrar(NroIndividuos, MaximoFx,0);
Gener_Anterior.CalcularAdaptacion(MaximoFx,NroIndividuos);
Superman = Gener_Anterior.SuperIndividuo(NroIndividuos,MaximoFx);
Promedio[0] = Gener_Anterior.PromedioAdaptabilidad(NroIndividuos);
MejorAdap[0] = Superman.Adaptacion(MaximoFx);
outtextxy(50,430,"Mejor -->");
Superman.Mostrar(430);
setcolor(3);
outtextxy(125,427, " ");
outtextxy(125,428, " ");
outtextxy(125,429, " ");
outtextxy(125,430, " ");
outtextxy(125,431, " ");
outtextxy(125,432, " ");
outtextxy(125,433, " ");
outtextxy(125,434, " ");
Monitor.CerrarVentana(16,160,620,415,1,3);
int Limite = NroIndividuos/2, Gener, Reprod, Padre, Madre, Pos;
for ( Gener = 1; Gener <= NroGeneraciones; Gener++)
{
Monitor.CerrarVentana(16,160,620,415,1,3);
Gener_Anterior.CalcularAdaptacion(MaximoFx,NroIndividuos);
Promedio[Gener] = Gener_Anterior.PromedioAdaptabilidad(NroIndividuos);
MejorAdap[Gener] = Superman.Adaptacion(MaximoFx);
Pos = 0;
for ( Reprod = 1; Reprod <= Limite; Reprod++)
{
Padre = Gener_Anterior.Seleccionar(MaximoFx, NroIndividuos);
Madre = Gener_Anterior.Seleccionar(MaximoFx,NroIndividuos);
Gener_Anterior.Reproducir(ProbCruce,Madre,Padre);
Decendencia[0] = Gener_Anterior.Hijo1();
Decendencia[1] = Gener_Anterior.Hijo2();
Decendencia[0].Mutar(ProbMutacion);
Decendencia[1].Mutar(ProbMutacion);
Gener_Siguiente.Agregar_Individuo( Decendencia, Pos);
Pos = Pos + 2;
} Ciclo de Reproducciones
Gener_Siguiente.Ordenar(NroIndividuos,MaximoFx);
Gener_Siguiente.Mostrar(NroIndividuos,MaximoFx,Gener);
Superman = Gener_Anterior.SuperIndividuo(NroIndividuos,MaximoFx);
setcolor(3);
outtextxy(125,427, " ");
outtextxy(125,428, " ");
outtextxy(125,429, " ");
outtextxy(125,430, " ");
outtextxy(125,431, " ");
outtextxy(125,432, " ");
outtextxy(125,433, " ");
outtextxy(125,434, " ");
Superman.Mostrar(430);
Gener_Anterior = Gener_Siguiente;
} Nro De Generaciones
setcolor(3);
outtextxy(125,427, " ");
outtextxy(125,428, " ");
outtextxy(125,429, " ");
outtextxy(125,430, " ");
outtextxy(125,431, " ");
outtextxy(125,432, " ");
outtextxy(125,433, " ");
outtextxy(125,434, " ");
setcolor(0);
Superman = Gener_Anterior.SuperIndividuo(NroIndividuos,MaximoFx);
Superman.Mostrar(430);
getch();
Monitor.CerrarVentana(10,50,630,450,9,7);
Gener_Anterior.Liberar();
Gener_Siguiente.Liberar();
}
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void Entrada( Pantalla Monitor )
{
Monitor.AbrirVentana(80,100,555,350);
setcolor(BLACK);255
settextstyle(TRIPLEX_FONT, HORIZ_DIR, 3);
outtextxy(180,110,"Algoritmo Genetico Simple");
settextstyle(0, 0, 1);
outtextxy(190,160,"Nro De Generaciones: ");
outtextxy(190,200,"Nro Individuos: ");
outtextxy(190,240,"Probabilidad Cruce:");
outtextxy(190,280,"Probabilidad Mutacion:");
Monitor.Mensaje ( "Introduzca Numero de Generaciones");
NroGeneraciones = Monitor.Captura( 380, 160);
Monitor.Mensaje ( "Introduzca Numero de Individuos Por Generacion");
NroIndividuos = Monitor.Captura( 380, 200);
Monitor.Mensaje ( "Introduzca Probabilidad de Cruce o Reproduccion");
ProbCruce = Monitor.Captura( 380, 240);
Monitor.Mensaje ( "Introduzca Probabilidad De Mutacion");
ProbMutacion = Monitor.Captura( 380, 280);
Monitor.Botoncito(270,310);
getch();
Monitor.CerrarVentana(80,100,555,350,9,7);
}
- - - - - - - - - - - - Metodos Individuo - - - - - - - - - - - - - - - -
int Individuo::SacarGen(int Gen)
{
return Cromosoma[Gen];
}
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Individuo::Individuo()
{
ValorReal = 0;
Adaptabilidad = 0;
Acumulador = 0;
} Individuo
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void Individuo::InsertarGen(int Valor, int Gen)
{
Cromosoma[Gen] = Valor;
} Insertar Gen
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void Individuo::Mostrar( int Linea)
{
int Ap;
int Columna = 130;
for ( Gen = 0; Gen < MaxGenes; Gen++ )
{
if (Cromosoma[Gen]==0)
{ setcolor(BLACK);
outtextxy(Columna, Linea, "0");} else
{ setcolor(WHITE);
outtextxy(Columna, Linea, "1");}
Columna = Columna + 8;
}
setcolor(BLACK);
RealWritexy(335, Linea, ValorReal);
RealWritexy(500, Linea, Adaptabilidad);
} Mostrar
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void Individuo::RealWritexy( int X, int Y, float Numero )
{
int Decimales, Signo;
char *Cadena, AuxCad[4];
Cadena = ecvt(Numero, 4, &Decimales, &Signo);
if ( Decimales == 0 )
{
outtextxy(X, Y,"0.");
outtextxy(X+15, Y,Cadena);
} else
{
for (int Pos = 0; Pos <= 3; Pos++) { AuxCad[Pos] = '';}
for (Pos = 0; Pos < Decimales; Pos++)
{
AuxCad[Pos] = Cadena[Pos];
}
outtextxy(X, Y,AuxCad);
outtextxy(X+8, Y,".");
char AuxCad2[4];
for (Pos = 0; Pos <= 3; Pos++) { AuxCad2[Pos] = '';}
int I = 0;
for (Pos = Decimales; Pos < 4; Pos++)
{
AuxCad2[I] = Cadena[Pos];
I++;
}
outtextxy(X+15, Y,AuxCad2);
}
}
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
float Individuo::Aleatorio(float Minimo, float Maximo)
{
float X, Dif;
Dif = Maximo - Minimo;
X = (float)rand()/32767;
return X*Dif+Minimo;
}; Aleatorio Entre Minimo y Maximo
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void Individuo::Mutar(float ProbMutacion)
{
for (Gen = 0; Gen < MaxGenes - 1; Gen ++ )
{
if (Aleatorio(0.0,1.0) <= ProbMutacion)
{
if (Aleatorio(0.0,1.0) >= 0.5)
{ Cromosoma[Gen] = 1; } else
{ Cromosoma[Gen] = 0; }
} If
} For
} Mutar
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
float Individuo::Adaptacion (float MaximoFx)
{
float Fx;
Fx = pow(ValorReal*sin(Base*M_PI*ValorReal),2)+1;
Adaptabilidad = Fx/MaximoFx;
return Adaptabilidad;
} Adaptacion
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void Individuo::Conversion()
{
ValorReal = LimInf-(Acumulador*((LimInf-LimSup)/Constante));
} Conversion
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void Individuo::Decodificar()
{
int Exponente = 0;
int Potencia;
unsigned int AcumuladorAux = 0;
for ( Gen = (MaxGenes-1); Gen >= 0; Gen-- )
{
if ( Cromosoma[Gen] > 0)
{
Potencia = pow(2, Exponente);
AcumuladorAux = AcumuladorAux+ Potencia;
} if
Exponente++;
} For
Acumulador = AcumuladorAux;
} Decodificar
- - - - - - - - - - - - Metodos Poblacion - - - - - - - - - - - - - - - -
float Generacion::PromedioAdaptabilidad(int NumIndividuos)
{
return TotalAdaptacion/NumIndividuos;
} Promedio Adaptabilidad
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void Generacion::Liberar()
{
free(Poblacion);
} Liberar
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void Generacion::Ordenar(int NumIndividuos, float MaximoFx)
{
Individuo Aux;
float Adap1,Adap2;
for (int i=0; i < NumIndividuos-1; i++)
{
for (int j = 0; j < (NumIndividuos-1)-i ;j++)
{
Adap1 = Poblacion[j].Adaptacion(MaximoFx);
Adap2 = Poblacion[j+1].Adaptacion(MaximoFx);
if (Adap2 > Adap1)
{
for (Gen = 0; Gen < MaxGenes; Gen++)
{ int Valor = Poblacion[j].SacarGen(Gen);
Aux.InsertarGen(Valor, Gen);
Valor = Poblacion[j+1].SacarGen(Gen);
Poblacion[j].InsertarGen(Valor, Gen);
Valor = Aux.SacarGen(Gen);
Poblacion[j+1].InsertarGen(Valor, Gen);
}
}
}
}
} Ordenar
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Generacion::Generacion(int NumIndividuos)
{
Poblacion = new Individuo[NumIndividuos];
int Valor;
TotalAdaptacion = 0;
for (Indiv = 0; Indiv < NumIndividuos; Indiv++)
{
for (Gen = 0; Gen < MaxGenes; Gen++)
{
Valor = random(2);
Poblacion[Indiv].InsertarGen(Valor,Gen);
} For
} For
} Poblacion
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
int Generacion::Seleccionar(float MaximoFx, int NroIndividuos)
{
float AleatorioAux = 0.0, PartSum = 0.0;
AleatorioAux = Aleatorio(0.0,1.0) * TotalAdaptacion;
Indiv = 0;
PartSum = PartSum+Poblacion[Indiv].Adaptacion(MaximoFx);
while ( PartSum < AleatorioAux && Indiv < NroIndividuos )
{
Indiv++;
PartSum = PartSum+Poblacion[Indiv].Adaptacion(MaximoFx);
}
return Indiv;
} Seleccionar
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void Generacion::Mostrar(int NumIndividuos, float MaximoFx, int Generacion)
{
setcolor(BLACK);
int Ap, Ap2;
setcolor(3);
outtextxy(198,127, " ");
outtextxy(198,128, " ");
outtextxy(198,129, " ");
outtextxy(198,130, " ");
outtextxy(198,131, " ");
outtextxy(198,132, " ");
outtextxy(198,133, " ");
outtextxy(198,134, " ");
setcolor(0);
outtextxy(60,130,"Generacion --> ");
outtextxy(200,130,fcvt(Generacion,0,&Ap,&Ap2));
outtextxy(60,150,"Indiv Cromosoma Valor Real Adaptabilidad");
int Linea = 160;
int Limite = 23;
for ( Indiv = 0; Indiv < NumIndividuos; Indiv++)
{
outtextxy(60, Linea,fcvt(Indiv,0,&Ap,&Ap2));
Poblacion[Indiv].Decodificar();
Poblacion[Indiv].Conversion();
Poblacion[Indiv].Adaptacion(MaximoFx);
Poblacion[Indiv].Mostrar(Linea);
Linea = Linea + 10;
if (Indiv >= Limite)
{ Limite = Limite + 23;
getch();
bar(16,160,620,415);
Linea = 160;
}
}
}
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void Generacion::CalcularAdaptacion(float MaximoFx, int NroIndividuos)
{
float Total = 0.0;
for (Indiv = 0; Indiv < NroIndividuos; Indiv++ )
{
Poblacion[Indiv].Decodificar();
Poblacion[Indiv].Conversion();
Total= Total+ Poblacion[Indiv].Adaptacion (MaximoFx);
} For
TotalAdaptacion = Total;
} Calcular Adaptacion De La Poblacion
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void Generacion::Reproducir(float ProbCruce, int Padre1, int Padre2 )
{ int Valor;
if (Aleatorio(0.0,1.0) <= ProbCruce)
{
int Corte = random(MaxGenes);
for (Gen = 0; Gen < Corte; Gen ++ )
{
Valor = Poblacion[Padre1].SacarGen(Gen);
Decendencia[0].InsertarGen(Valor, Gen);
Valor = Poblacion[Padre2].SacarGen(Gen);
Decendencia[1].InsertarGen(Valor,Gen);
} For
for (Gen = Corte; Gen < MaxGenes; Gen++ )
{ Valor = Poblacion[Padre2].SacarGen(Gen);
Decendencia[0].InsertarGen(Valor, Gen);
Valor = Poblacion[Padre1].SacarGen(Gen);
Decendencia[1].InsertarGen(Valor, Gen);
} For
} else { for (Gen = 0; Gen < MaxGenes; Gen++)
{ Valor = Poblacion[Padre1].SacarGen(Gen);
Decendencia[0].InsertarGen(Valor, Gen);
Valor = Poblacion[Padre2].SacarGen(Gen);
Decendencia[1].InsertarGen(Valor, Gen);
}
}
} Reproducir
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Individuo Generacion::Hijo1()
{
return Decendencia[0];
} Reproducir Hijo 2
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Individuo Generacion::Hijo2()
{
return Decendencia[1];
} Reproducir Hijo 2
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void Generacion::Agregar_Individuo( Individuo Decendencia[NroHijos], int Pos )
{
for (Gen = 0; Gen < MaxGenes; Gen++)
{ int Valor = Decendencia[0].SacarGen(Gen);
Poblacion[Pos].InsertarGen(Valor, Gen);
Valor = Decendencia[1].SacarGen(Gen);
Poblacion[Pos+1].InsertarGen(Valor, Gen);
}
} Agregar Individuo
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Individuo Generacion::SuperIndividuo(int NroIndividuos, float MaximoFx)
{
float Mejor = 0.0;
for (Indiv = 0; Indiv < NroIndividuos; Indiv++ )
{
Poblacion[Indiv].Decodificar();
Poblacion[Indiv].Conversion();
if (Poblacion[Indiv].Adaptacion(MaximoFx) > Mejor)
{ Mejor = Poblacion[Indiv].Adaptacion (MaximoFx);
SuperIndiv = Poblacion[Indiv]; }
} For
return SuperIndiv;
} Super Individuo
- - - - - - - - - - - - - - - Metodos de Pantalla - - - - - - - - - - - -
void Pantalla::Grafica2(int NroGeneraciones, int Cuantos)
{
float St[10];
St[0] = 0.1;
St[1] = 0.2;
St[2] = 0.3;
St[3] = 0.4;
St[4] = 0.5;
St[5] = 0.6;
St[6] = 0.7;
St[7] = 0.8;
St[8] = 0.9;
St[9] = 1.0;
int Columna1 = 70;
int Columna2 = 70+Cuantos;
setcolor(9);
for ( int Gener = 0; Gener < NroGeneraciones; Gener++)
{
int Fila1 = 400;
int Pos = 0, Salir = 0;
while (Salir = 1)
{
if (ProbMutacion1[Gener] >= St[Pos])
{ Fila1 = Fila1 - 25; } else { Salir = 1; }
Pos++;
}
int Fila2 = 400;
Pos = 0;
Salir = 0;
while (Salir = 1)
{
if (ProbMutacion1[Gener+1] >= St[Pos])
{ Fila2 = Fila2 - 25; } else { Salir = 1; }
Pos++;
}
line ( Columna1,Fila1, Columna2, Fila2);
line ( Columna1,Fila1-1, Columna2, Fila2-1);
Columna1 = Columna1 + Cuantos;
Columna2 = Columna2 + Cuantos;
}
Columna1 = 70;
Columna2 = 70+Cuantos;
setcolor(10);
for ( Gener = 0; Gener < NroGeneraciones; Gener++)
{
int Fila1 = 400;
int Pos = 0, Salir = 0;
while (Salir = 1)
{
if (ProbMutacion2[Gener] >= St[Pos])
{ Fila1 = Fila1 - 25; } else { Salir = 1; }
Pos++;
}
int Fila2 = 400;
Pos = 0;
Salir = 0;
while (Salir = 1)
{
if (ProbMutacion2[Gener+1] >= St[Pos])
{ Fila2 = Fila2 - 25; } else { Salir = 1; }
Pos++;
}
line ( Columna1,Fila1, Columna2, Fila2);
line ( Columna1,Fila1-1, Columna2, Fila2-1);
Columna1 = Columna1 + Cuantos;
Columna2 = Columna2 + Cuantos;
}
Columna1 = 70;
Columna2 = 70+Cuantos;
setcolor(12);
for ( Gener = 0; Gener < NroGeneraciones; Gener++)
{
int Fila1 = 400;
int Pos = 0, Salir = 0;
while (Salir = 1)
{
if (ProbMutacion3[Gener] >= St[Pos])
{ Fila1 = Fila1 - 25; } else { Salir = 1; }
Pos++;
}
int Fila2 = 400;
Pos = 0;
Salir = 0;
while (Salir = 1)
{
if (ProbMutacion3[Gener+1] >= St[Pos])
{ Fila2 = Fila2 - 25; } else { Salir = 1; }
Pos++;
}
line ( Columna1,Fila1, Columna2, Fila2);
line ( Columna1,Fila1-1, Columna2, Fila2-1);
Columna1 = Columna1 + Cuantos;
Columna2 = Columna2 + Cuantos;
}
}
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void Pantalla::Grafica3(int NroGeneraciones, int Cuantos)
{
float St[10];
St[0] = 0.1;
St[1] = 0.2;
St[2] = 0.3;
St[3] = 0.4;
St[4] = 0.5;
St[5] = 0.6;
St[6] = 0.7;
St[7] = 0.8;
St[8] = 0.9;
St[9] = 1.0;
int Columna1 = 70;
int Columna2 = 70+Cuantos;
setcolor(9);
for ( int Gener = 0; Gener < NroGeneraciones; Gener++)
{
int Fila1 = 400;
int Pos = 0, Salir = 0;
while (Salir = 1)
{
if (ProbCruce1[Gener] >= St[Pos])
{ Fila1 = Fila1 - 25; } else { Salir = 1; }
Pos++;
}
int Fila2 = 400;
Pos = 0;
Salir = 0;
while (Salir = 1)
{
if (ProbCruce1[Gener+1] >= St[Pos])
{ Fila2 = Fila2 - 25; } else { Salir = 1; }
Pos++;
}
line ( Columna1,Fila1, Columna2, Fila2);
line ( Columna1,Fila1-1, Columna2, Fila2-1);
Columna1 = Columna1 + Cuantos;
Columna2 = Columna2 + Cuantos;
}
Columna1 = 70;
Columna2 = 70+Cuantos;
setcolor(10);
for ( Gener = 0; Gener < NroGeneraciones; Gener++)
{
int Fila1 = 400;
int Pos = 0, Salir = 0;
while (Salir = 1)
{
if (ProbCruce2[Gener] >= St[Pos])
{ Fila1 = Fila1 - 25; } else { Salir = 1; }
Pos++;
}
int Fila2 = 400;
Pos = 0;
Salir = 0;
while (Salir = 1)
{
if (ProbCruce2[Gener+1] >= St[Pos])
{ Fila2 = Fila2 - 25; } else { Salir = 1; }
Pos++;
}
line ( Columna1,Fila1, Columna2, Fila2);
line ( Columna1,Fila1-1, Columna2, Fila2-1);
Columna1 = Columna1 + Cuantos;
Columna2 = Columna2 + Cuantos;
}
Columna1 = 70;
Columna2 = 70+Cuantos;
setcolor(12);
for ( Gener = 0; Gener < NroGeneraciones; Gener++)
{
int Fila1 = 400;
int Pos = 0, Salir = 0;
while (Salir = 1)
{
if (ProbCruce3[Gener] >= St[Pos])
{ Fila1 = Fila1 - 25; } else { Salir = 1; }
Pos++;
}
int Fila2 = 400;
Pos = 0;
Salir = 0;
while (Salir = 1)
{
if (ProbCruce3[Gener+1] >= St[Pos])
{ Fila2 = Fila2 - 25; } else { Salir = 1; }
Pos++;
}
line ( Columna1,Fila1, Columna2, Fila2);
line ( Columna1,Fila1-1, Columna2, Fila2-1);
Columna1 = Columna1 + Cuantos;
Columna2 = Columna2 + Cuantos;
}
}
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void Pantalla::Grafica1(int NroGeneraciones, int Cuantos)
{
float St[10];
St[0] = 0.1;
St[1] = 0.2;
St[2] = 0.3;
St[3] = 0.4;
St[4] = 0.5;
St[5] = 0.6;
St[6] = 0.7;
St[7] = 0.8;
St[8] = 0.9;
St[9] = 1.0;
int Columna1 = 70;
int Columna2 = 70+Cuantos;
setcolor(9);
for ( int Gener = 0; Gener < NroGeneraciones; Gener++)
{
int Fila1 = 400;
int Pos = 0, Salir = 0;
while (Salir = 1)
{
if (MejorAdap[Gener] >= St[Pos])
{ Fila1 = Fila1 - 25; } else { Salir = 1; }
Pos++;
}
int Fila2 = 400;
Pos = 0;
Salir = 0;
while (Salir = 1)
{
if (MejorAdap[Gener+1] >= St[Pos])
{ Fila2 = Fila2 - 25; } else { Salir = 1; }
Pos++;
}
line ( Columna1,Fila1, Columna2, Fila2);
line ( Columna1,Fila1-1, Columna2, Fila2-1);
Columna1 = Columna1 + Cuantos;
Columna2 = Columna2 + Cuantos;
}
Columna1 = 70;
Columna2 = 70+Cuantos;
setcolor(10);
for ( Gener = 0; Gener < NroGeneraciones; Gener++)
{
int Fila1 = 400;
int Pos = 0, Salir = 0;
while (Salir = 1)
{
if (Promedio[Gener] >= St[Pos])
{ Fila1 = Fila1 - 25; } else { Salir = 1; }
Pos++;
}
int Fila2 = 400;
Pos = 0;
Salir = 0;
while (Salir = 1)
{
if (Promedio[Gener+1] >= St[Pos])
{ Fila2 = Fila2 - 25; } else { Salir = 1; }
Pos++;
}
line ( Columna1,Fila1, Columna2, Fila2);
line ( Columna1,Fila1-1, Columna2, Fila2-1);
Columna1 = Columna1 + Cuantos;
Columna2 = Columna2 + Cuantos;
}
}
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
float Pantalla::Captura(int X1, int Y1)
{
char Tecla;
char Cadena[6];
for ( int Pos = 0; Pos <= 5; Pos++) { Cadena[Pos] = '';}
Pos = 0;
setcolor(15);
do
switch (Tecla = getch()) {
case 0: { break;}
default: if ((Tecla = 13) && ( Tecla = 27))
{Cadena[Pos] = Tecla;
outtextxy(X1, Y1, Cadena);
Pos ++;}
}
while ( Tecla = 13 );
return atof(Cadena);
}
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void Pantalla::AbrirVentana(int X1, int Y1, int X2, int Y2)
{
setfillstyle(1,3);
for ( int Pos = Y1+4; Pos <= Y2; Pos ++)
{
setcolor(8);
bar(X1,Y1,X2,Pos++);
setcolor(12);
rectangle(X1,Y1,X2,Pos++);
rectangle(X1+4,Y1+4,X2-4,(Pos++)-4);
delay(3);
}
} Abrir Ventana
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void Pantalla::CerrarVentana( int X1, int Y1, int X2, int Y2, int Estilo, int Color)
{
setfillstyle(Estilo, Color);
bar(X1, Y1, X2, Y2);
}
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
char Pantalla::Salir(void)
{
AbrirVentana(170,280,455,410);
setcolor(14);
settextstyle(0, 0, 1);
outtextxy(225,310,"¨Esta seguro de salir?");
char Aux = (Botoncitos(205,360,290,385));
CerrarVentana(170,280,455,410,9,7);
return Aux;
}
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void Pantalla::Botoncito(int x, int y)
{
setfillstyle(1,7);
bar(x,y,x+75,y+20);
setcolor(1);
rectangle(x,y,x+75,y+20);
setcolor(0);
outtextxy(x+12,y+8,"Aceptar");
}
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
char Pantalla::Botoncitos(int fila1, int col1, int fila2, int col2)
{
char Op=1, Ch;
setcolor(7);
setfillstyle(1,7);
bar(fila1,col1,fila2,col2);
bar(fila1+125,col1,fila2+125,col2);
setcolor(1);
rectangle(fila1,col1,fila2,col2);
rectangle(fila1+125,col1,fila2+125,col2);
setcolor(0);
outtextxy(fila1+15, col1+10,"Aceptar");
outtextxy(fila1+137, col1+10,"Cancelar");
setcolor(12);
rectangle(fila1,col1,fila2,col2);
do {
if ((Ch=getch()) ==0) Ch=getch();
switch (Ch) { A la izquierda
case 'K' : if (Op = 1) {
setcolor(12);
rectangle(fila1,col1,fila2,col2);
setcolor(1);
rectangle(fila1+125,col1,fila2+125,col2);
Op--;
}
break;
case 'M' : if (Op = 2) { A la derecha
setcolor(12);
rectangle(fila1+125,col1,fila2+125,col2);
setcolor(1);
rectangle(fila1,col1,fila2,col2);
Op++;
}
break;
}
} while ((Ch=13) && (Ch=27));
if (Ch==27) return 2;
else return Op;
}
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void Pantalla::Mensaje ( char Mensaje[30] )
{
setcolor (CYAN);
outtextxy(70,459,"***************************************************");
outtextxy(70,460,"***************************************************");
outtextxy(70,461,"***************************************************");
outtextxy(70,462,"***************************************************");
outtextxy(70,463,"***************************************************");
outtextxy(70,464,"***************************************************");
outtextxy(70,465,"***************************************************");
setcolor (BLACK);
outtextxy(70,462,Mensaje);
}
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
int Pantalla::FormatoGrafica(int NroGeneraciones,int Opcion)
{
setcolor(BLACK);
settextstyle(TRIPLEX_FONT, HORIZ_DIR, 3);
outtextxy(100,70,"Estadisticas - ");
if (Opcion == 1)
{outtextxy(265,70,"Mejor Adaptado Vs. Promedio");
settextstyle(0, 0, 1);
setcolor(9);
line (100, 120, 120, 120);
line (100, 121, 120, 121);
setcolor(10);
line (400, 120, 420, 120);
line (400, 121, 420, 121);
setcolor(6);
outtextxy(130,120,"Mejor Adaptado");
outtextxy(430,120,"Promedio");
} else
if (Opcion == 2)
{ outtextxy(265,70,"Probabilidades de Mutaciones");
settextstyle(0, 0, 1);
} else
if (Opcion == 3)
{ outtextxy(265,70,"Probabilidades de Cruces");
settextstyle(0, 0, 1);
}
setcolor(BLACK);
line (70,400,600,400); Eje X
line (70,401,600,401); Eje X
line (70,100,70,400); Eje Y
line (71,101,71,400); Eje Y
setcolor(LIGHTRED);
settextstyle(0, 0, 1);
outtextxy(240,423,"Generaciones");
outtextxy(596,397,">");
settextstyle(0, 1, 1);
outtextxy(30,200,"Adaptabilidad");
outtextxy(75,98,">");
setcolor(YELLOW);
settextstyle(0, 0, 0);
line (67,375,70,375); outtextxy(40,375,"0.1");
line (67,350,70,350); outtextxy(40,350,"0.2");
line (67,325,70,325); outtextxy(40,325,"0.3");
line (67,300,70,300); outtextxy(40,300,"0.4");
line (67,275,70,275); outtextxy(40,275,"0.5");
line (67,250,70,250); outtextxy(40,250,"0.6");
line (67,225,70,225); outtextxy(40,225,"0.7");
line (67,200,70,200); outtextxy(40,200,"0.8");
line (67,175,70,175); outtextxy(40,175,"0.9");
line (67,150,70,150); outtextxy(40,150,"1.0");
int Cuantos = 520/NroGeneraciones;
int Columna = Cuantos+70;
for ( int Gener = 1; Gener <= NroGeneraciones; Gener++)
{
line(Columna,401,Columna,404);
Columna = Columna + Cuantos;
};
return Cuantos;
} Formato Grafica
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void Pantalla::MenuHorizontal()
{
setfillstyle(1,8); Sombra barra superior
bar(xAct+8, 10 , 638, 33);
setfillstyle(1,3);
bar(xAct-1, 0, 632, 27); menu Principal
setcolor(1);
rectangle(xAct+1, 2, 630, 25);
setcolor(3);
bar(xAct,455, 635,475); Barra Inferior
setcolor(1);
rectangle(xAct+2,457, 633,474); Rectangulo Inferior
setcolor(0);
settextstyle(0, 0, 1);
outtextxy( 30,10,"Entrada");
outtextxy(138,10,"Calcular Max");
outtextxy(278,10,"Graficas");
outtextxy(395,10,"Acerca de..");
outtextxy(535,10,"Salir");
} Menu Horizontal
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
int Pantalla::OpcionHorizontal(int Op)
{
char Ch;
setcolor(1);
rectangle(xAct+8, 4, xAct+104, 23);
do {
if ( Op == 1 ) { Mensaje ("Leer Datos"); }
else
if ( Op == 2 ) { Mensaje("Obtener Solucion"); }
else
if ( Op == 3 ) { Mensaje("Graficas - Estadisticas"); }
else
if ( Op == 4 ) { Mensaje("Acerca de Los Autores"); }
else
if ( Op == 5 ) { Mensaje("Salir Del Sistema"); }
if ((Ch=getch()) == 0) Ch = getch();
switch (Ch) {
case 'K' : setcolor(3);
rectangle(xAct+8, 4, xAct+104, 23);
setcolor(1);
if (Op = 1) {
xAct -= 125;
Op--;
}
else {
xAct = 505; 452
Op = 5;
}
rectangle(xAct+8, 4, xAct+104, 23);
break;
case 'M' : setcolor(3);
rectangle(xAct+8, 4, xAct+104, 23);
setcolor(1);
if (Op = 5) {
xAct += 125; 112
Op++;
}
else {
xAct = 5;
Op = 1;
}
rectangle(xAct+8, 4, xAct+104, 23);
break;
}
} while (Ch=13 && Ch=27);
if (Ch==27) return 0;
else return Op;
} Opcion Horizontal
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Pantalla::Pantalla (char Ruta[15])
{
/* request auto detection */
int gdriver = DETECT, gmode, Selec;
/* initialize graphics, local variables */
initgraph(&gdriver, &gmode, Ruta);
if (graphresult() = grOk) {
printf("Error Gr fico\n");
printf("Presione cualquier tecla para salir...\n\n");
getch();
exit(1);
}
} Pantalla
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void Pantalla::Cerrar()
{
closegraph();
} Cerrar
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void Pantalla::Acercade()
{
AbrirVentana(170,120,452,350);
setcolor(14);255
outtextxy(220,170,"Algoritmo Genetico Simple");
setcolor(11);
outtextxy(265,185,"Versi¢n 1.0");
outtextxy(225,200,"Copyright (c) 1999 por");
setcolor(0);
outtextxy(200,230,"Tacoa Morales, Alirio Adolfo");
outtextxy(200,260,"Perez T. Freddy De Jesus");
Botoncito(270,310);
Mensaje ( "Pulse Cualquier Tecla Para Continuar");
getch();
CerrarVentana(170,120,452,350,9,7);
} Acerca de..
- - - - - - - - - - - - - - - Principal - - - - - - - - - - - - - - - - -
void main(void)
{
Pantalla Monitor("c:\\tc\\bgi");
setfillstyle(9,7);
bar(0,0,650,625);
int Cuantas_Van = 0;
Monitor.MenuHorizontal();
int Seleccion = 1, Opcion = 1;
int Entro = 0; False;
while (Seleccion = 0)
{
Opcion = Monitor.OpcionHorizontal(Opcion);
switch (Opcion) {
case 0 : { if (Monitor.Salir() == 1)
Seleccion = 0;
break;
}
case 1 : { Entrada(Monitor);
Entro = 1;
Cuantas_Van++;
break;}
case 2 : { if (Entro == 1) { Obtener_Solucion(Monitor);
switch(Cuantas_Van) {
case 1: { for (int Pos = 0; Pos <= NroGeneraciones; Pos++)
{
ProbMutacion1[Pos] = MejorAdap[Pos];
ProbCruce1[Pos] = Promedio[Pos];
}
break;
}
case 2: { for (int Pos = 0; Pos <= NroGeneraciones; Pos++)
{
ProbMutacion2[Pos] = MejorAdap[Pos];
ProbCruce2[Pos] = Promedio[Pos];
}
break;
}
case 3: { for (int Pos = 0; Pos <= NroGeneraciones; Pos++)
{
ProbMutacion3[Pos] = MejorAdap[Pos];
ProbCruce3[Pos] = Promedio[Pos];
}
break;
}
default: break;
}
}
else { Monitor.Mensaje("Debe Ejecutar El Menu Entrada");
getch(); }
break;}
case 3 : { if (Entro == 1){
Monitor.AbrirVentana(10,50,630,450);
int Cuantos = Monitor.FormatoGrafica(NroGeneraciones, 1);
Monitor.Grafica1(NroGeneraciones,Cuantos);
Monitor.Mensaje ( "Pulse Cualquier Tecla Para Continuar");
getch();
Monitor.CerrarVentana(10,50,630,450,9,7);
Monitor.AbrirVentana(10,50,630,450);
Cuantos = Monitor.FormatoGrafica(NroGeneraciones,2);
Monitor.Grafica2(NroGeneraciones, Cuantos);
Monitor.Mensaje ( "Pulse Cualquier Tecla Para Continuar");
getch();
Monitor.CerrarVentana(10,50,630,450,9,7);
Monitor.AbrirVentana(10,50,630,450);
Cuantos = Monitor.FormatoGrafica(NroGeneraciones,3);
Monitor.Grafica3(NroGeneraciones, Cuantos);
Monitor.Mensaje ( "Pulse Cualquier Tecla Para Continuar");
getch();
Monitor.CerrarVentana(10,50,630,450,9,7);}
else { Monitor.Mensaje("Debe Ejecutar El Menu Entrada");
getch(); }
break;}
case 4 : { Monitor.Acercade();
break;}
case 5 : { if (Monitor.Salir() == 1)
Seleccion = 0;
break;
}
}
}
Monitor.Cerrar();
} Funcion Main
Por: Alirio Adolfo Tacoa Morales Freddy De Jesus Perez T.