Algoritmo Genetico Simple en C++

  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.