jueves, 13 de octubre de 2011

WSDL Web Services Description Language

WSDL Web Services Description Language

WSDL son las siglas de  , un formato XML que se utiliza para describir servicios Web (algunas personas lo leen como wisdel). La versión 1.0 fue la primera recomendación por parte del W3C y la versión 1.1 no alcanzó nunca tal estatus. La versión 2.0 se convirtió en la recomendación actual por parte de dicha entidad.
WSDL describe la interfaz pública a los servicios Web. Está basado en XML y describe la forma de comunicación, es decir, los requisitos del protocolo y los formatos de los mensajes necesarios para interactuar con los servicios listados en su catálogo. Las operaciones y mensajes que soporta se describen en abstracto y se ligan después al protocolo concreto de red y al formato del mensaje.
Así, WSDL se usa a menudo en combinación con SOAP y XML Schema. Un programa cliente que se conecta a un servicio web puede leer el WSDL para determinar qué funciones están disponibles en el servidor. Los tipos de datos especiales se incluyen en el archivo WSDL en forma de XML Schema. El cliente puede usar SOAP para hacer la llamada a una de las funciones listadas en el WSDL.
El WSDL nos permite tener una descripción de un servicio web. Especifica la interfaz abstracta a través de la cual un cliente puede acceder al servicio y los detalles de cómo se debe utilizar.

Contenido

Estructura del WSDL

Como vemos, la estructura del WSDL tiene los siguientes elementos:

Tipos de Datos

<types>: Esta sección define los tipos de datos usados en los mensajes. Se utilizan los tipos definidos en la especificación de esquemas XML.

Mensajes

<message>: Aquí definimos los elementos de mensaje. Cada mensaje puede consistir en una serie de partes lógicas. Las partes pueden ser de cualquiera de los tipos definidos en la sección anterior.

Tipos de Puerto

<portType>: Con este apartado definimos las operaciones permitidas y los mensajes intercambiados en el Servicio.

Bindings

<binding>: Especificamos los protocolos de comunicación usados.

Servicios

<service>: Conjunto de puertos y dirección de los mismos. Esta parte final hace referencia a lo aportado por las secciones anteriores.
Con estos elementos no sabemos que hace un servicio pero si disponemos de la información necesaria para interactuar con él (funciones, mensajes de entrada/salida, protocolos...).

Freddy Perez Computacion y Sistemas freperez98@gmail.com Aragua Venezuela

XML Schema

XML Schema
XML Schema es un lenguaje de esquema utilizado para describir la estructura y las restricciones de los contenidos de los documentos XML de una forma muy precisa, más allá de las normas sintácticas impuestas por el propio lenguaje XML. Se consigue así una percepción del tipo de documento con un nivel alto de abstracción. Fue desarrollado por el World Wide Web Consortium (W3C) y alcanzó el nivel de recomendación en mayo de 2001.

Contenido

Terminología
El término "XML Schema" es utilizado con varios significados dentro del mismo contexto de descripción de documentos, y es importante tener en cuenta las siguientes consideraciones:
  1. "XML Schema" (Esquema XML) es el nombre oficial otorgado a la recomendación del W3C, que elaboró el primer lenguaje de esquema separado de XML (la definición de tipo de documentos (DTD) forma parte de XML).
  2. Es habitual referirse a los esquemas como "XML schema" de forma genérica, pero se recomienda utilizar el término “documento esquema” (schema document) o "definición de esquema"(schema definition), y reservar “XML Schema” para la denominación de este lenguaje específico.
  3. Aunque genéricamente se utilice "XML schemas", XSDL (XML Schema Definition Language) es el nombre técnico de los lenguajes de esquema de XML como:
·         Definición de Tipo de Documento (DTD)
·         XML Schema
·         RELAX NG
·         Schematron
·         Namespace Routing Language (NRL)
·         Document Schema Definition Languages (DSDL)
·         Document Definition Markup Language (DDML)
·         Document Structure Description (DSD)
·         SGML
·         Schema for Object-Oriented XML (SOX)
W3C Schema XML
El World Wide Web Consortium (W3C) empezó a trabajar en XML Schema en 1998. La primera versión se convirtió en una recomendación oficial en mayo de 2001. Una segunda edición revisada está disponible desde octubre de 2004.
Esta recomendación está desarrollada en tres partes:
  • XML Schema Parte 0 Primer: es una introducción no normativa al lenguaje, que proporciona una gran cantidad de ejemplos y explicaciones detalladas para una primera aproximación a XML Schema.
  • XML Schema Parte 1 Structures: es una extensa descripción de los componentes del lenguaje.
  • XML Schema Parte 2 Datatypes: complementa la Parte 1 con la definición de los tipos de datos incorporados en XML Schema y sus restricciones.
Componentes
XML Schema es un lenguaje de esquema escrito en XML, basado en la gramática y pensado para proporcionar una mayor potencia expresiva que las DTD, menos capaces al describir los documentos a nivel formal.
Los documentos esquema (usualmente con extensión .xsd de XML Schema Definition (XSD)) se concibieron como una alternativa a las DTD, más complejas, intentando superar sus puntos débiles y buscar nuevas capacidades a la hora de definir estructuras para documentos XML. El principal aporte de XML Schema es el gran número de tipos de datos que incorpora. De esta manera, XML Schema aumenta las posibilidades y funcionalidades de aplicaciones de procesado de datos, incluyendo tipos de datos complejos como fechas, números y strings.
Tipos de componentes
Los esquemas XML Schema superan muchas de las limitaciones y debilidades de las DTDs. Fue diseñado completamente alrededor de namespaces y soporta tipos de datos típicos de los lenguajes de programación, como también tipos personalizados simples y complejos. Un esquema se define pensando en su uso final.
Namespaces
La programación en Schema XML se basa en Namespaces. Podemos encontrar una analogía entre éstos y los llamados packages en Java. Cada Namespace contiene elementos y atributos que están estrechamente relacionados con el Namespace. Así, a la hora de definir un elemento o un atributo de un Namespace, siempre se creará una conexión entre los diferentes campos de éste. Además, esta forma de trabajar nos permite relacionar elementos que no están en el mismo Namespace.
Después de escribir un Schema XML se puede confirmar la correcta realización mediante la validación de esquemas XML: Validación XML.5623
Ejemplo
Un ejemplo de la estructura de un documento esquema vacío sería el siguiente:
 <?xml version="1.0" encoding="ISO-8859-1"?>
 <xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema" version="0.1" xml:lang="es">
 </xsd:schema>
Un ejemplo de definición con XML Schema sería el siguiente:
<?xml version="1.0" encoding="UTF-8"?>
<xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema">
     <xsd:element name="Libro">
         <xsd:complexType>
            <xsd:sequence>
                 <xsd:element name="Título" type="xsd:string"/>
                 <xsd:element name="Autores" type="xsd:string" maxOccurs="10"/>
                 <xsd:element name="Editorial" type="xsd:string"/>
            </xsd:sequence>
            <xsd:attribute name="precio" type="xsd:double"/>
        </xsd:complexType>
   </xsd:element>
</xsd:schema>
Podemos ver como en ambos casos se inician las declaraciones indicando la versión de XML que se va a utilizar y la codificación que se usa. Estos dos campos son necesarios para poder interpretar el esquema. Además, en la siguiente línea de código podemos ver como se redirecciona al usuario a la página que ofrece las pautas de creación de XML Schema en las que se basará la descripción del esquema.
El elemento raíz se llama “Libro” y tiene tres hijos (elementos anidados) y un atributo. Los hijos son “Titulo”,”Editorial” que deben aparecer una vez y “Autores” que puede aparecer de una a diez veces. El hecho de que estén agrupados en una secuencia indica que los elementos deben aparecer en orden, es decir, primero el “Titulo”, luego los “Autores” y por último la “Editorial”. Los tres elementos son de tipo string. El atributo de libro se llama “precio” y es de tipo double.

Freddy Perez Computacion y Sistemas freperez98@gmail.com Aragua Venezuela

miércoles, 5 de octubre de 2011

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.  

ODBC NO SE VE. MAPEANDO COMO UNIDAD DE RED

ODBC NO SE VE. MAPEANDO COMO UNIDAD DE RED Para configurar el  EnableLinkedConnections  valor de registro: Haga clic en Inicio, escriba rege...