SIMULADOR PARA LA CONSTRUCCIN DE CIRCUITOS COMBINACIONALES POR MEDIO DE ALGORITMOS GENTICOS CON APLICACIN A UN SUMADOR DE 3 BITS, ORIENTADO A DISPOSITIVOS

REPROGRAMABLES

German Flrez Larrahondo Miguel Eduardo Torres Moreno

UNIVERSIDAD NACIONAL DE COLOMBIA FACULTAD DE INGENIERIA DEPARTAMENTO DE INGENIERIA DE SISTEMAS SANTAFE DE BOGOTA 1999

SIMULADOR PARA LA CONSTRUCCIN DE CIRCUITOS COMBINACIONALES POR MEDIO DE ALGORITMOS GENTICOS CON APLICACIN A UN SUMADOR DE 3 BITS, ORIENTADO A DISPOSITIVOS REPROGRAMABLES

GERMAN FLREZ LARRAHONDO MIGUEL EDUARDO TORRES MORENO

Tesis entregada como parte de los requisitos para optar al ttulo de Ingeniero de Sistemas

Director JORGE EDUARDO ORTIZ TRIVIO Ingeniero de Sistemas Codirector FABIO GONZALEZ OSORIO

UNIVERSIDAD NACIONAL DE COLOMBIA FACULTAD DE INGENIERIA DEPARTAMENTO DE INGENIERIA DE SISTEMAS SANTAFE DE BOGOTA 1999

Calificacin de aceptacin

Director

Codirector

Jurado

Jurado

Santaf de Bogot, Agosto de 1999

COMENTARIOS

TABLA DE CONTENIDO
INTRODUCCION 9

1. MARCO TEORICO 1.1. HARDWARE EVOLUTIVO

10 10 10 10 11 11 12 13 13 13 14 14 15 15 16 16 16 17 17 17 18 18 19 19 19 20 20 20

1.1.1. INTRODUCCIN 1.1.2. EVOLUCIN 1.1.2.1. Evolucin artificial 1.1.3. DEFINICIN DE HARDWARE EVOLUTIVO 1.1.4. ARQUITECTURA DEL HARDWARE EVOLUTIVO 1.1.5. DISEO EVOLUTIVO 1.1.5.1.Ventajas del Diseo Evolutivo 1.1.6. HARDWARE EVOLUTIVO: EN PERSPECTIVA 1.2. INTRODUCCION A LOS ALGORITMOS GENETICOS 1.2.1. GENERALIDADES 1.2.2. DESCRIPCIN DE UN ALGORITMO GENTICO SIMPLE 1.2.2.1. Estructuras y Datos 1.2.2.2. Codificacin Binaria 1.2.2.3. Codificacin con Caracteres y Valores Reales 1.2.2.4. Estructura en Arbol 1.2.2.5. Algoritmo Gentico Simple General 1.2.2.5.1. Obtencin de la Primera Generacin 1.2.2.5.2. Evaluacin de las Cadenas 1.2.2.5.3. Seleccin de Estructuras 1.2.2.5.4. Cruzamiento 1.2.2.5.5. Mutacin de Cadenas 1.2.3. OTRAS CARACTERSTICAS 1.2.3.1. Mtodos de Seleccin 1.2.3.1.1. Seleccin Proporcional a la Aptitud con Juego de Ruleta 1.2.3.1.2. Escalizacin Sigma 1.2.3.1.3. Elitismo

1.2.3.1.4. Seleccin por Clasificacin 1.2.3.1.5. Seleccin por Torneo 1.2.3.2. Operadores Genticos 1.2.3.2.1. Cruce 1.2.3.2.2. Mutacin 1.3. PROGRAMACION GENETICA 1.3.1. INTRODUCCIN 1.3.2. SELECCIN DEL LENGUAJE DE PROGRAMACIN 1.3.2.1 Por Que LISP 1.3.3. CARACTERSTICAS DE LA PROGRAMACIN GENTICA 1.3.3.1. Las Estructuras que Sufren Adaptacin 1.3.3.1.1. Cierre 1.3.3.1.2. Suficiencia 1.3.3.2. Las Estructuras Iniciales 1.3.3.3. La Aptitud 1.3.3.4.Operaciones para la Modificacin de Estructuras 1.3.3.4.1. Reproduccin 1.3.3.4.2. Cruce (Recombinacin) 1.3.3.5. El Estado del Sistema 1.3.3.6. Designacin del Resultado 1.3.3.7. Terminacin 1.3.3.8. Parmetros de Control 1.3.4. FUNCIONES PREDEFINIDAS 1.3.5. ALGORITMO DE DEJOUNG 1.4. CIRCUITOS LOGICOS COMBINATORIOS 1.4.1. DEFINICIN 1.4.2. LGICA BINARIA 1.4.2.1. Adicin Lgica 1.4.2.2. Multiplicacin Lgica 1.4.2.3. Inversin Lgica 1.4.3. OTRAS COMPUERTAS LGICAS 1.4.3.1. Compuerta Or Exclusiva 1.4.3.2. Compuerta Nand 1.4.3.3. Compuerta Nor 1.4.3.4. Importancia de las Compuertas Nand y Nor 1.4.4. DISEO ANALTICO DE CIRCUITOS LGICOS COMBINATORIOS

20 21 21 21 22 22 22 23 25 26 27 29 29 29 31 34 34 34 37 37 37 38 38 38 39 39 40 40 41 41 42 42 43 44 44 45

1.4.4.1. Simplificacin de Funciones 1.4.4.2. Mapas De Karnaugh 1.4.4.3. Teoremas de Boole y Morgan 1.4.5. EJEMPLOS 1.4.5.1. Sumadores 1.4.5.1.1. Sumador Medio 1.4.5.1.2. Sumador Total 1.4.5.2. Sustractores 1.4.5.2.1. Sustractor Medio 1.4.5.2.2. Sustractor Completo 1.4.5.3. Relacin Entre Sumadores y Sustractores 1.4.5.4. Generacin y Comprobacin de Paridad 1.4.5.5. Decodificadores 1.5. LENGUAJE VHDL 1.5.1. INTRODUCCIN A VHDL 1.5.1.1. Breve Resea Histrica 1.5.1.2. Caractersticas 1.5.1.3. Ventajas 1.5.1.4. Desventajas 1.5.2. MTODOS DE DISEO 1.5.2.1. Diseo Estructural 1.5.2.2. Diseo por Flujo de Datos 1.5.2.3. Diseo de Comportamiento 1.5.3. APROXIMACIN AL DISEO ESTRUCTURAL 1.5.3.1. Definicin de Bloques 1.5.3.2. Entidad 1.5.3.3 Tipos De Seales 1.5.3.4. Arquitectura 1.5.3.4.1. Operadores Lgicos 1.5.3.4.2. Sentencia With-Select 1.5.3.5. Componentes e Instancias 1.6. FIELD PROGRAMMABLE GATE ARRAY: FPGA 1.6.1. CONCEPTOS BSICOS 1.6.2. FPGA SERIE XC4000 1.6.2.1. Descripcin 1.6.2.2. Componentes Bsicos

46 46 47 48 48 48 48 50 50 50 51 51 52 53 53 53 53 54 55 55 55 56 56 56 57 57 58 59 60 60 61 64 64 65 66 66

1.6.2.2.1 Bloques Lgicos Configurables 1.6.2.2.2. Bloques de Entrada/Salida 1.6.2.2.3. Buffers de Tres Estados 1.6.2.2.4. Interconexiones 1.6.2.3. Reconfiguracin del FPGA 1.6.2.3.1. Reconfiguracin Esttica 1.6.2.3.2. Reconfiguracin Dinmica 1.6.2.4. Programacin del FPGA 1.6.2.4.1. Captura del Diseo 1.6.2.4.2. Implementacin del Diseo 1.6.2.4.3. Verificacin del Diseo 1.6.2.4.4. Configuracin 2. ANALISIS Y DISEO DEL PROBLEMA 2.1. METODOLOGIA 2.2. ANALISIS DEL PROBLEMA PARA EL DESARROLLO DEL MODELO 2.2.1. ANLISIS PRELIMINAR 2.2.2. ESPECIFICACIN DE REQUERIMIENTOS 2.2.2.1 Entradas 2.2.2.2. Algoritmo de Programacin Gentica 2.2.2.3. Salidas 2.3. DISEO DE LA APLICACION. 2.3.1. DESCOMPOSICIN FUNCIONAL 2.3.2. FLUJO DE DATOS

66 67 68 68 68 69 69 69 69 70 71 71 72 72 72 72 72 73 73 74 74 74 75 76

2.3.3. DEFINICIN DE LA ESTRUCTURA LISP (ARBOLES) Y CONSIDERACIONES INICIALES DEL PROBLEMA 2.3.3.1. La Raz 2.3.3.2. Las Funciones 2.3.3.3. Las Terminales 2.3.3.4. Ejemplo 2.3.4. CLASES 2.3.4.1. Lista Preliminar de Clases 2.3.4.2. Lista Final de Clases 2.3.4.3. Registro De Clases 2.3.4.4. Diagrama de Colaboraciones Entre Objetos 76 76 77 77 77 77 79 79 85

2.3.5. DIAGRAMA DE TRANSICIN DE ESTADOS 2.3.5.1. Descripcin de las Transiciones 2.4. IMPLEMENTACION 2.4.1. HERRAMIENTAS DE DESARROLLO 2.4.2. HERRAMIENTAS ADICIONALES 2.4.2.1. GALIB 2.4.2.2. Xilinx Foundation Software 2.4.2.3. RANDOMLIB 2.4.3. MODULO TABLAS DE VERDAD 2.4.3.1. Especificacin de Requerimientos 2.4.3.2. Clases 2.4.3.2.1. Lista Preliminar de Clases 2.4.3.2.2. Lista Final de Clases 2.4.3.2.3. Registro de Clases 2.4.3.2.4. Diagrama de Colaboraciones Entre Objetos 2.4.4. DIAGRAMA DE TRANSICIN DE ESTADOS 2.4.4.1. Descripcin de las Transiciones 3. PRUEBAS Y RESULTADOS 3.1. SUMADOR COMPLETO DE 3 BITS 3.1.1. EJEMPLO RESULTANTE CON LA TODAS LAS FUNCIONES BSICAS 3.1.2. EJEMPLO RESULTANTE SIN EL USO DE LA COMPUERTA XOR 3.1.3. RESULTADOS CON FUNCIONES DEFINIDAS POR EL USUARIO 3.1.3.1. Ejemplo Resultante Con Funciones de Usuario 3.2. MULTIPLEXOR DE 2 ENTRADAS DE DOS BITS 3.2.1. EJEMPLO RESULTANTE 3.2.2.EJEMPLO CON FUNCIONES DE USUARIO LOGROS

85 86 86 86 87 87 87 87 87 87 88 88 88 88 91 91 91 93 93 95 97 100 100 104 105 107 115

CONCLUSIONES Y RECOMENDACIONES

117

BIBLIOGRAFIA

118

MANUAL DEL USUARIO

120

HOJA TECNICA

129

ANEXOS

130

ANEXO A. METODOLOGIA DE ANALISIS Y DISEO

130

ANEXO B. GALIB

133

ANEXO C. XILINX FOUNDATION F1.5

141

INDICE DE ILUSTRACIONES
Figura 1 La S-expresin LISP (+ 1 2 (IF (> TIEMPO 10) 3 4)) dibujada como un rbol con los nodos rotulados y las ramas ordenadas[3]. ..............................................................................................................................................25 Figura 2 Arbol LISP correspondiente a la S-expresin (OR (AND(NOT D0) (NOT D1)) (AND D0 D1)) ..................28 Figura 3 La generacin de un rbol aleatorio podra empezar con etiquetar la raz del rbol con la funcin +.......30 Figura 4 La generacin de un rbol aleatorio podra continuar con etiquetar un punto interior con la funcin *. ...30 Figura 5 La generacin de un rbol aleatorio podra continuar con etiquetar un punto externo con la terminal A. .31 Figura 6 Dos S-expresiones LISP. ...............................................................................................................................35 Figura 7 Dos fragmentos seleccionados para cruce de los padres de la Figura 6 ......................................................36 Figura 8 Descendencia producida por el operador de cruce que usa a los padres de Figura 6 y los fragmentos de cruce de la figura 7. .....................................................................................................................................................36 Figura 9 Esquema de un circuito lgico combinacional..............................................................................................39 Figura 10 Esquema de un circuito lgico secuencial...................................................................................................39 Figura 11 Compuerta OR.............................................................................................................................................41 Figura 12 Compuerta AND ..........................................................................................................................................41 Figura 13 Negador.......................................................................................................................................................42 Figura 14 Compuerta XOR. .........................................................................................................................................43 Figura 15 Compuerta NAND. ......................................................................................................................................44 Figura 16 Compuerta NOR. .........................................................................................................................................44 Figura 17 Equivalencias para diferentes compuertas..................................................................................................45 Figura 18 Esquema lgico de un sumador de tres bits usando Sumadores Totales.....................................................49 Figura 19 Estructura de un CPLD. ..............................................................................................................................64 Figura 20 Estructura de un FPGA. ..............................................................................................................................66 Figura 21 Estructura de un Bloque Lgico..................................................................................................................67 Figura 22 Estructura de un Bloque E-S. ......................................................................................................................68 Figura 23 Captura del diseo en FOUNDATION de XILINX. ....................................................................................70 Figura 24 cdigo XNF de un diseo capturado en FOUNDATION SERIES de Xilinx................................................71 Figura 25 Diagrama de Flujo de datos de la Aplicacin.............................................................................................73 Figura 26 Diagrama de Representacin Funcional de la Aplicacin..........................................................................74 Figura 27 Descomposicin por mdulos de la aplicacin. ..........................................................................................76 Figura 28 Representacin lgica y de rbol de un circuito sumador completo de 2 bits, cuya representacin LISP corresponde a: CONCAT((XOR(A B))(AND(A B))).....................................................................................................77 Figura 29 Diagrama de Colaboraciones Entre Objetos. .............................................................................................85 Figura 30 Diagrama de Transicin de Estados. ..........................................................................................................86 Figura 31 Colaboraciones entre objetos del mdulo Editor de tablas.........................................................................91 Figura 32 Diagrama de Transicin de Estados. ..........................................................................................................91

INDICE DE TABLAS
Tabla 1 Combinaciones Posibles .................................................................................................................................39 Tabla 2 Valores Booleanos ..........................................................................................................................................40 Tabla 3 Tabla de verdad de la adicin lgica..............................................................................................................40 Tabla 4 Tabla de verdad de la multiplicacin lgica...................................................................................................41 Tabla 5 Tabla de verdad de la inversin lgica ...........................................................................................................42 Tabla 6 Tabla de verdad de la compuerta XOR ...........................................................................................................43 Tabla 7 Tabla de verdad de la compuerta NAND ........................................................................................................43 Tabla 8 Tabla de verdad de la compuerta NOR..........................................................................................................44 Tabla 9 Ejemplo de un Mapa de Karnaugh..................................................................................................................46 Tabla 10 Ejemplo de tabla de verdad...........................................................................................................................47 Tabla 11 Mapa de Karnaugh para el ejemplo de tabla de verdad ...............................................................................47 Tabla 12 Teoremas de Boole y Morgan .......................................................................................................................48 Tabla 13 Tabla de verdad del sumador medio .............................................................................................................48 Tabla 14 Tabla de verdad del sumador total................................................................................................................49 Tabla 15 Tabla de verdad del sustractor medio...........................................................................................................50 Tabla 16 Tabla de verdad del sustractor completo ......................................................................................................50 Tabla 17 Tabla de verdad del generador de paridad impar ........................................................................................51 Tabla 18 Tabla de verdad del operador de equivalencia.............................................................................................52 Tabla 19 Tabla de verdad del circuito de comprobacin de paridad impar ................................................................52 Tabla 20 Tabla de verdad de un circuito decodificador de lnea de 2 a 4 ...................................................................53 Tabla 21 Elementos bsicos de la declaracin de una entidad....................................................................................58 Tabla 22 Valores del tipo STD_LOGIC .......................................................................................................................58 Tabla 23 Elementos bsicos de la declaracin de una arquitectura............................................................................59 Tabla 24 Comportamiento del circuito circuito_sumador ...........................................................................................61 Tabla 25 Lista preliminar de clases .............................................................................................................................78 Tabla 26 Lista preliminar de clases .............................................................................................................................88 Tabla 27 Tabla de verdad del sumador completo de 3 bits..........................................................................................93 Tabla 28 Resuman del comportamiento para el sumador de 3 bits .............................................................................95 Tabla 29 Resumen del comportamiento sin utilizar la funcin XOR............................................................................96 Tabla 30 Resumen del comportamiento utilizando funciones de usuario ..................................................................100 Tabla 31 Resumen del comportamiento para el multiplexor de 2 entradas ...............................................................104

INTRODUCCION
Actualmente muchos problemas en aprendizaje de mquinas, inteligencia artificial, y procesamiento simblico pueden resolverse con una bsqueda en el espacio de programas, para encontrar la solucin que ms se ajuste a las necesidades planteadas por el problema. Es entonces cuando aparece la programacin gentica, mtodo que brinda una forma eficiente para realizar esta bsqueda y obtener una solucin (aproximada) al problema dado, por medio de la coexistencia de una poblacin de individuos (programas) interactuando entre s por el principio Darviniano de la supervivencia del individuo ms apto. De ella misma surge entonces el Hardware Evolutivo, proceso de adaptacin mediante el cual se manipula la arquitectura de estructuras Hardware (en este caso particular se manipulan estructuras software que representan una estructura hardware) por medio de la interaccin con el ambiente. En el caso particular de esta investigacin el problema planteado consiste en buscar por medio de la programacin gentica la generacin de un programa VHDL (Very High Speed Integrated Circuits Hardware Description Lenguage, que significa, Lenguaje de Descripcin de Hardware para Circuitos Integrados de Alta Velocidad), que contenga el comportamiento de un circuito lgico combinatorio, buscado por el usuario. SimEHDL es uno de los primeros trabajos realizados en la Universidad Nacional de Colombia, que aplica los conceptos de programacin gentica orientada hacia el naciente campo del Hardware Evolutivo, el cual pretende demostrar la factibilidad de desarrollo de este tipo de aplicaciones, as como su utilidad en diferentes reas. En el primer captulo se exponen las bases tericas que soportaron el desarrollo del proyecto. Comprende la descripcin y funcionamiento un algoritmo gentico y su especializacin en la programacin gentica, conceptos bsicos sobre circuitos lgicos combinatorios, lenguaje VHDL, y dispositivos reprogramables FPGA. En el segundo captulo se describe el proceso de anlisis, diseo e implementacin del simulador, el cual fue llevado a cabo siguiendo las etapas descritas por la metodologa tradicional del ciclo de vida del software, adems se enumeran las herramientas utilizadas durante el proceso de implementacin. En el ltimo captulo se describen pruebas realizadas al simulador con diferentes circuitos combinatorios y sus resultados. En la parte final de este captulo se detallan las conclusiones y logros obtenidos luego de la elaboracin de la presente investigacin.

1. MARCO TEORICO
1.1. HARDWARE EVOLUTIVO
1.1.1. Introduccin

Los organismos vivientes son sistemas complejos que exhiben un rango de caractersticas especiales tales como evolucin, adaptacin, y tolerancia a los fallos. Dichos rasgos han mostrado ser de difcil comprensin usando metodologas de ingeniera tradicionales. Sin embargo, desde hace algn tiempo se ha introducido en la ingeniera un conjunto de conceptos basados en procesos de seres vivos, tales como las redes neuronales y la evolucin de individuos. Estos sistemas que evolucionan se caracterizan por un programa gentico (genoma), que define el desarrollo del ser o individuo, su funcionamiento y extincin.
1.1.2. Evolucin

La evolucin es un proceso incesante en el que entidades biolgicas se adaptan en un entorno variable. Es un procedimiento que ocurre gradualmente tras centenares de miles de generaciones para crear especies que se adaptan especficamente al ambiente en cualquier momento en particular. Para explicar la evolucin, se deben estudiar algunos aspectos biolgicos simples. Cada ser viviente en la tierra posee una cadena de ADN que le identifica(genotipo). El genotipo describe de una manera compleja (a travs del uso de interacciones qumicas) cmo construir una entidad biolgica especfica (fenotipo), por ejemplo un ser humano. Cuando dos fenotipos se reproducen para crear descendencia, el ADN de los dos padres es mezclado para crear una nueva cadena de ADN. La multiplicacin de los organismos vivientes se basa en la reproduccin del programa(ADN), sujeto a una proporcin de error sumamente baja a nivel individual, para asegurar que la identidad de la descendencia permanezca prcticamente inalterada. La mutacin (reproduccin asexual) junto con la recombinacin (reproduccin sexual) da lugar a la emergencia de nuevos organismos. Los mecanismos de la filogentica (evolucin de las especies) son fundamentalmente no-deterministicos, la rata de mutacin y la proporcin de recombinacin brindan una fuente mayor de diversidad. Esta diversidad es indispensable para la supervivencia de las especies vivientes, para su adaptacin continua a un ambiente cambiante, y para la aparicin de nuevas especies.

10

As se tiene que la filognesis (Evolucin) es la que mejor describe lo que se conoce como Hardware Evolutivo, siendo este referenciado intuitivamente como evolucin artificial, lo que a su vez nos lleva a los algoritmos genticos, programacin evolutiva, etc. Inicialmente es necesario crear una medida de aptitud para cada individuo: Un individuo nacer sin defectos, vivir hasta la edad de reproduccin y se reproducir con un individuo semejantemente. Los genes en el ADN describen a un individuo apto o no (los aptos y no aptos son evaluados de acuerdo a nuestra medida). Si un gen es apto se le permite al individuo reproducirse ms a menudo que otros individuos, este gen ser mas til y podr ser llevado a una prxima generacin. Si un gen es malo se elimina el individuo antes que este puede reproducirse, dicho gen no continuar en la prxima generacin. As es como ocurre la evolucin ciertos genes nos permiten vivir y por consiguiente aumentar las oportunidades de reproduccin. As los genes avanzan a travs de las generaciones logrando solo la supervivencia de los mejores o ms aptos.

1.1.2.1. Evolucin artificial

La Evolucin artificial es el proceso de aplicar la evolucin a sistemas artificiales. La base de estos sistemas es la creacin artificial de ADN y un mtodo para combinarlo. El trabajo que debe hacerse es la traduccin del genotipo al fenotipo y la medicin de la aptitud de este ltimo dentro del ambiente. Un primer mtodo fue descrito por J. Holland en su libro, "La Adaptacin en sistemas naturales y artificiales", y se le llam Algoritmos Genticos.
1.1.3. Definicin de Hardware Evolutivo

Hardware Evolutivo (Evolvable Hardware, conocido con las siglas EHW) es la aplicacin de estrategias biolgicas sobre dispositivos electrnicos. La idea lleg despus que un desarrollador de algoritmos genticos hablo sobre la existencia de dispositivos electrnicos los cuales tienen la capacidad de ser programados usando cadenas binarias. Esta idea dio pie a la investigacin especfica en dos reas diferentes: EHW Extrnseco Un algoritmo evolutivo crea una configuracin para el hardware cuya aptitud se efecta sobre una simulacin del Hardware EHW Intrnseco La aptitud del individuo es evaluada transmitiendo la configuracin al hardware y evaluando el sistema in-situ. En el EHW, la adaptacin equivale a la modificacin directa de las estructuras del hardware acorde a las influencias recibidas del entorno. Esto brinda ventajas como la adaptacin en tiempo real, la flexibilidad y tolerancia a fallos. 11

Se han visto progresos significativos en investigacin sobre hardware basado en maquinas como Perceptrn, WISARD, y ALNs (redes lgicas adaptativas). El hardware evolutivo, sin embargo, a estado limitado, en el sentido que en la mayora de experimentos realizados hasta ahora la adaptacin que se lleva a cabo es off-line o extrnseca. Sin embargo, las mquinas adaptativas ideales deben poder cambiar su estructura fsica mientras son usadas en tiempo real (es decir con adaptacin on-line o intrnseca). Con tal adaptacin, se pueden evitar funcionamientos defectuosos del hardware en sistemas de computacin usados en circunstancias extraordinarias como en el espacio y el fondo del mar. La distincin ms clara entre el hardware convencional (CHW) y EHW radica en que el diseo de CHW no puede iniciar hasta que se den las caracterstica tcnicas del hardware al diseador. Por otro lado, el EHW puede usarse en situaciones donde nadie sabe la especificacin del hardware deseada previamente. El EHW puede reconfigurar su estructura a travs de aprendizaje gentico.

1.1.4. Arquitectura del Hardware evolutivo

El proceso de adaptacin es una combinacin de aprendizaje gentico con aprendizaje reforzado. A continuacin se define el procesamiento de arquitecturas paralelas para Hardware evolutivo. Se denomina hardware reconfigurable al sistema que puede definir su comportamiento de acuerdo a una configuracin dada externamente (realmente un conjunto de bits). Dicha configuracin es capaz de alterar fsicamente el dispositivo lgico y puede cambiarse varias veces. Entonces, al utilizar sistemas reconfigurables, el proceso evolutivo puede llevarse a cabo en la cadena de bits que es capaz de determinar el comportamiento del circuito. Incorporando ambos, aprendizaje reforzado y aprendizaje gentico, el EHW puede seleccionar por si mismo la arquitectura lgica del dispositivo que da mayor rendimiento con respecto a su entorno. El esquema de aprendizaje gentico es paralelo a los algoritmos genticos. Los GAs operan sobre una poblacin de cadenas de bits cada una de las cuales determina la arquitectura del dispositivo reprogramable. Los GAs pueden obtener la mejor cadena de bits (individuo) una alta posibilidad de sobrevivir y recombinarse. De esta forma se llega a una nueva generacin de individuos que incorporan algunas caractersticas de sus antecesores. Esta nueva generacin es entonces alimentada al dispositivo el cual presentar un nuevo comportamiento. Su rendimiento es evaluado y el proceso se repite nuevamente. El aprendizaje por refuerzo es el segundo esquema de aprendizaje incorporado el EHW. Las entradas son cambiadas basndose en la retribucin a continuacin de la respuesta que exhibe el sistema (retroalimentacin). Esta retribucin es relacionada a la calidad de la respuesta y podra tardarse. La finalidad es maximizar o minimizar una retribucin negativa. No hay ningn maestro o supervisor involucrado en este esquema de aprendizaje 12

1.1.5. Diseo Evolutivo

Para el caso en el cual el EHW es aplicado como alternativa para el diseo de circuitos se presentan dos faces: 1. Diseo Evolutivo: Proceso en el cual por medio de tcnicas evolutivas, se busca una arquitectura que represente un circuito determinado. 2. Ejecucin: Consiste en la implementacin fsica de la arquitectura encontrada. De lo anterior se desprende entonces una clasificacin dependiente de la representacin del cromosoma [1]: 1. Representacin Directa: El cromosoma configura una arquitectura en bits de diferentes componentes hardware o de compuertas lgicas. 2. Representacin Indirecta: El cromosoma es una representacin de un lenguaje de alto nivel en forma de rboles gramaticales, los cuales son usados para generar los circuitos.

1.1.5.1.Ventajas del Diseo Evolutivo

En esencia la aproximacin convencional especifica como disear e implementar un circuito, mientras la aproximacin evolutiva busca definir solamente el comportamiento del circuito. Las ventajas del mtodo evolutivo, respecto al convencional son: Evala un mayor rango de alternativas de aquellas consideradas por el ser humano. El diseo evolutivo no asume conocimiento anterior de cualquier dominio en particular. Puede ser aplicado por cualquier usuario sin tener que referirse a un dominio determinado. La aproximacin evolutiva puede trabajar con diferentes grados de restriccin y requerimientos. Si existe cualquier conocimiento anterior este puede ser aplicado para mejorar la eficiencia del diseo. Es importante notar que los experimentos de EHW conducidos hasta el momento han sido a pequea escala (es decir, que el EHW es pequeo en componentes en comparacin a los circuitos diseados por el mtodo tradicional), y aun con esa pequea cantidad de elementos, se ha experimentado el alto costo computacional del EHW.
1.1.6. Hardware Evolutivo: En Perspectiva

Si se observara hacia el futuro, el desarrollo del EHW sera de la siguiente forma:

13

Inicialmente se tiene lo que es en esencia el diseo evolutivo, donde todas las operaciones se llevan a cabo en software, con la posibilidad de cargar la solucin en un circuito real. Seguidamente, se encuentran trabajos en los que un circuito real es usado durante el proceso evolutivo, y la mayora de las operaciones se realizan extrnsecamente, en software. Por ejemplo, el calculo de la aptitud se puede realizar en el circuito. En la siguiente fase se encuentran sistemas en los que todas las operaciones genticas (seleccin, cruce, mutacin, y calculo de aptitud) se llevan a cabo en hardware (intrnseco). El mayor elemento perdido en esta parte se refiere al hecho de que la evolucin se lleva a cabo como un sistema cerrado, es decir, hay una meta predefinida y ningn entorno dinmico del cual tomar informacin. La ltima y ms importante fase es en la cual una poblacin de entidades hardware evoluciona en un entorno abierto. sta ltima fase para muchos investigadores es considerada como el verdadero hardware evolutivo. Una aplicacin natural en estos sistemas es el rea de los robots autnomos, que involucra maquinas capaces de operar en entornos desconocidos sin la intervencin humana.

1.2. INTRODUCCION A LOS ALGORITMOS GENETICOS

1.2.1. Generalidades

Fueron inventados por John Holland (1975), cuya inspiracin fue el proceso evolutivo presente en la naturaleza. As, un Algoritmo Gentico es una tcnica de optimizacin basada en la seleccin natural (cruce, mutacin y seleccin natural de individuos). Un Algoritmo Gentico (GA) es un procedimiento interactivo que consiste en una poblacin de tamao constante de individuos, cada uno representado por una cadena finita de smbolos codificando una posible solucin en algn espacio del problema. Este espacio tambin conocido como espacio de bsqueda, comprende todas las posibles soluciones del problema a mano. El alfabeto de smbolos es generalmente binario, gracias a su generalizacin y a otras propiedades matemticas. El GA estndar trabaja de la siguiente manera: Inicialmente una poblacin de individuos es generada aleatoria o heursticamente. En cada paso evolutivo llamado generacin, los individuos en la poblacin actual son decodificados y evaluados de acuerdo a algunos criterios predefinidos de seleccin, referidos como aptitud. Para formar los individuos de la siguiente generacin, los individuos son seleccionados con una probabilidad proporcional a su aptitud, esto asegura que el nmero de veces que un individuo es seleccionado es proporcional a su actuacin dentro de la poblacin; esto significa que a mayor aptitud tenga un individuo, mayor ser el chance de que este se reproduzca. La seleccin no puede en si introducir nuevos individuos a la poblacin; estos son generados por medio de operadores genticos, de los cuales los ms usados son: cruce y mutacin. Combinando la supervivencia de los mejores individuos dentro de un conjunto, los ms aptos, con un intercambio de informacin estructurado y aleatorio, que imita los procesos de evolucin biolgica.

14

Los Algoritmos Genticos son algoritmos evolutivos ya que explotan eficientemente la informacin histrica, permitiendo especular sobre nuevos puntos de bsqueda, dentro del espacio de soluciones, esperando un mejor comportamiento a travs de su evolucin. El objetivo de los Algoritmos Genticos es doble: (1) explicar rigurosamente los procesos adaptativos de los sistemas naturales, y (2) disear software de sistemas artificiales, que contengan los mecanismos ms importantes de los sistemas naturales. El ingeniero, diseador de sistemas artificiales, solo puede maravillarse ante la robustez, la eficiencia, y la flexibilidad de los sistemas biolgicos. Caractersticas como autoreparacin, autogua, y reproduccin, son la regla de los sistemas biolgicos, caractersticas de las que generalmente carecen los sistemas artificiales ms sofisticados. As se llega a una conclusin interesante: donde se requiera un comportamiento robusto, la naturaleza lo ha hecho mejor. Los secretos de la adaptacin y la supervivencia se aprenden mejor del estudio cuidadoso del ejemplo biolgico.
1.2.2. Descripcin de un Algoritmo Gentico Simple

Los mecanismos de un Algoritmo Gentico Simple, A.G.S., son sorprendentemente sencillos, lo ms complejo que incluyen son la copia de cadenas y el intercambio parcial de cadenas. A continuacin se presenta, la implementacin de un A.G.S. Un Algoritmo Gentico Simple, que da buenos resultados en muchos problemas prcticos, se compone de tres operadores: Seleccin. Cruce. Mutacin. Primero se estudiar un algoritmo genrico A.G.S. para luego continuar examinando detalladamente cada uno de los operadores anteriores.

1.2.2.1. Estructuras y Datos

Se definen los principales parmetros de un A.G.S., como son: Nmero de generaciones (M). Tamao de la poblacin (K). Estructura del cromosoma, as como lo relacionado a l como son: su decodificacin (su valor), su aptitud, y el porcentaje que su aptitud aporta a la aptitud total de la poblacin, adems de su longitud en bits (L).

El ltimo punto es en especial importante pues de l depende el xito del mtodo, ya que la estructura de datos del cromosoma define el espacio de soluciones del problema (en la mayora de los casos, mas no en todos, como se vera mas adelante). Desde el punto de vista de la 15

estructura de datos las aplicaciones ms comunes trabajan con listas lineales, con excepcin de la programacin gentica, donde se trabaja con estructuras en rbol.

1.2.2.2. Codificacin Binaria

Es la ms comn por razones histricas, ya que Holland concentr su trabajo en dicha configuracin y en la practica, muchos desarrolladores de algoritmos genticos han tendido a seguir este esquema. Adems, mucha de la teora existente sobre algoritmos genticos se basa en la suposicin de codificacin de longitud fija y codificacin binaria. Otro aspecto a considerar, es que independientemente de cualquier consideracin, toda codificacin es digital y binaria en la base, por ejemplo en el caso de los fonemas de un idioma, una vez digitalizados es muy sencillo aplicar los operadores genticos.

1.2.2.3. Codificacin con Caracteres y Valores Reales

Sin embargo, para muchos problemas, la codificacin binaria no es natural y no es tan ampliamente utilizada, por ejemplo en aprendizaje evolutivo de Redes Neuronales Artificiales, para la representacin de los pesos, o en la solucin de problemas de Programacin Lineal. Para muchas aplicaciones, es ms natural usar un alfabeto de muchos caracteres o de nmeros reales, para formar cromosomas. El Teorema del Algoritmo Gentico, sin embargo, parece implicar que los GAs, presentan un comportamiento inferior cuando se hace la codificacin con mltiples caracteres, que con codificacin binaria. Sin embargo, esto es muy cuestionable, pues varias comparaciones empricas entre codificacin binaria y codificacin de muchos caracteres o de valores reales han mostrado un mejor comportamiento de estas ultimas. Pero nuevamente, el comportamiento depende mucho del problema y de los detalles del algoritmo gentico que se esta usando y en este momento an no hay una gua rigurosa para predecir que codificacin trabajar mejor.

1.2.2.4. Estructura en rbol

La codificacin en rboles, como en la Programacin Gentica, de John Koza, donde cada cromosoma es un programa de computador, tiene varias ventajas, como la formacin de soluciones ms estructuradas y jerrquicas y que permiten que el espacio de bsqueda sea completamente abierto. Sin embargo, esta apertura lleva a algunos problemas potenciales, ya que los rboles pueden crecer tanto en formas no controladas, que los rboles resultantes son muy grandes y difciles de comprender y simplificar. Hasta ahora, la comunidad de la programacin gentica ha comenzado experimentos sistemticos, que evalan la utilidad de la codificacin de rboles, comparndolos con otras codificaciones. Hasta cuando la teora de algoritmos genticos y su codificacin, se formule de una manera ms eficaz, la mejor filosofa es estudiar los ejemplos presentados en la literatura y adecuarlos a la versin particular del algoritmo gentico.

16

1.2.2.5. Algoritmo Gentico Simple General

A continuacin, se presenta un algoritmo gentico general y universal, que con pocas modificaciones puede utilizarse para muchas aplicaciones. Producir la poblacin inicial de individuos. Evaluar la Aptitud de todos los individuos. Mientras no se cumpla la condicin de terminacin Haga. Seleccione los individuos ms aptos para reproduccin Recombine los individuos seleccionados. Mute algunos individuos. Evale la aptitud de los nuevos individuos. Genere una nueva poblacin insertando algunos buenos individuos y descarte algunos malos individuos. Fin Mientras.

1.2.2.5.1. Obtencin de la Primera Generacin

La primera generacin se produce aleatoriamente, con una poblacin de K individuos y cada uno con una longitud L de bits, cada uno de ellos generado aleatoriamente. La rutina simula el lanzamiento de una moneda, para generar aleatoriamente un bit, e iterativamente formar una cadena de 1s y 0s, y posteriormente la poblacin. Esta es una rutina universal para todos los algoritmos genticos simples.

1.2.2.5.2. Evaluacin de las Cadenas

Una vez se tiene la primera generacin de puntos del espacio de soluciones, se deben confrontar esos seres con su ambiente para medir su comportamiento y con base en l determinar su seleccin como progenitor de seres para la prxima generacin. Para esto se le aplica la funcin de adaptabilidad o aptitud. Inicialmente se calcula el valor de decodificacin del cromosoma. Y se suman todos los valores de cada individuo i. S = fi Y una probabilidad pi es asignada a cada cadena: pi = fi / S

17

1.2.2.5.3. Seleccin de Estructuras

La seleccin o reproduccin, es un proceso en que las cadenas individuales se copian de acuerdo a los valores se su funcin objetivo f. Los bilogos la llaman funcin de adaptabilidad. La copia de cadenas se efecta con base en el valor con que cada cadena contribuye a la adaptabilidad total de la poblacin. Obteniendo la probabilidad acumulada para cada individuo: ci = pi Un nmero aleatorio r, uniformemente distribuido en el rango [0,1], es generado tantas veces como individuos existen en la poblacin (K) y cada vez, el i-simo individuo es seleccionado de tal forma que ci-1 < r ci (S r<c1, la primera cadena es seleccionada). Este proceso puede visualizarse como un proceso de seleccin en una ruleta dividida en K segmentos cada una con un tamao proporcional a la aptitud del individuo que representa. Con este tipo de seleccin de ruleta, los individuos ms aptos tienen una mayor probabilidad de ser escogidos para reproduccin. Este operador, claramente, es una versin artificial de seleccin natural, se busca un superviviente Darviniano de los ms aptos entre las criaturas cadenas. En poblaciones naturales, la aptitud est determinada por la habilidad de la criatura para sobrevivir a depredadores, pestes, y otros obstculos para llegar a adultos y reproducir las criaturas siguientes. Una vez la poblacin ha sido seleccionada, las cadenas se forman en parejas aleatorias y se recombinan a travs del cruce

1.2.2.5.4. Cruzamiento

Despus de la reproduccin, el cruce simple puede proceder en dos pasos. Primero, los miembros de la cadena reproducidos recientemente en el juego de la ruleta, se mezclan al azar, para el apareamiento. Aqu se seleccionan dos parejas que son consecutivas en la generacin. Dado que fueron seleccionadas aleatoriamente tenemos una buena distribucin. Cada par de cadenas se cruza como sigue: se selecciona uniformemente una posicin entera j, que pertenece a la cadena, entre 1 y la longitud de la cadena menos 1 [1, L-1], se intercambian los bits de la posicin j en adelante de las dos cadenas, crendose dos nuevas cadenas. Por ejemplo, considere las cadenas A1 y A2 A1 = 0 1 1 ' 0 0 A2 = 1 1 0 ' 0 1 Suponga que se hizo la eleccin de un nmero aleatorio, entre 1 y 4, y se obtuvo j=4. El cruce resultante da dos nuevas cadenas, donde el (') significa las cadenas que forman parte de la nueva generacin: A1' = 0 1 1 0 1 A2' = 1 1 0 0 0 18

Los dos nuevos individuos reemplazan a sus padres en la poblacin de la siguiente generacin. El operador de cruce es aplicado con una cierta frecuencia pc, llamada tasa de cruzamiento; cualquier individuo toma parte en el proceso de recombinacin si una variable aleatoria uniformemente distribuida en el intervalo [0,1] tiene un valor pc. Un valor emprico usual para pc es 0.6. Como se puede observar, los mecanismos de reproduccin y cruce son sorprendentemente simples. Incluyen la generacin de nmeros aleatorios, copia de cadenas, y cierto intercambio parcial de cadenas. Sin embargo, el nfasis combinado de reproduccin y el intercambio estructurado de informacin, aunque al azar, da a los GAs mucha de su potencia.

1.2.2.5.5. Mutacin de Cadenas

La mutacin juega un papel secundario en los A.G., debido a que la frecuencia con que se realiza es extremadamente baja (empricamente es aplicada con una frecuencia pm=0.01). En el caso estndar un nmero aleatorio r es generado (con distribucin uniforme [0,1]) para cada bit de la poblacin; si r pm entonces el bit es intercambiado, si es 1 se pasa a 0, y si es 0 se pasa a 1. Otra forma es definir una probabilidad de mutacin, como en la ruleta y selecciona un bit de toda la poblacin. Este operador permite que haya exploracin en otras partes del espacio de bsqueda de manera que haya una completa exploracin para evitar la concentracin de los genes en mximos locales.
1.2.3. Otras Caractersticas
1.2.3.1. Mtodos de Seleccin

Despus de decidir sobre la codificacin del cromosoma, la segunda definicin importante que se debe tomar al usar un algoritmo gentico, es cmo efectuar la seleccin, es decir, como escoger los individuos para crear la descendencia en la siguiente generacin. El propsito de la seleccin es, naturalmente, destacar los mejores individuos en la poblacin, con la esperanza de que su descendencia tenga a su vez una aptitud mucho ms alta. La seleccin tiene que hacer un balance entre la variacin del cruce y la mutacin, es decir, un balance entre explotacin y exploracin. Una seleccin que hace mucho nfasis en la aptitud, lleva a que individuos aptos, altamente subptimos, se tomen la poblacin, reduciendo la diversidad necesaria para el cambio y progreso posteriores. Una seleccin que hace poco nfasis en la aptitud, producir una evolucin demasiado lenta y ruidosa. As como en la codificacin, se han propuesto numerosos mtodos de seleccin en la literatura. A continuacin se describen los ms comunes.

19

1.2.3.1.1. Seleccin Proporcional a la Aptitud con Juego de Ruleta

El algoritmo gentico original de Holland us la seleccin proporcional a la aptitud, en la cual el valor esperado de reproduccin de un individuo, es decir, el nmero de veces que se selecciona ese individuo, es la aptitud de ese individuo dividida por la aptitud promedio de la poblacin. El mtodo ms comn para implementarlo, es el de la ruleta descrito anteriormente, donde a cada individuo se le asigna un arco del crculo de la ruleta, correspondiente a la aptitud del individuo. La rueda se gira el nmero veces que sea necesario, hasta seleccionar el nmero de individuos de la poblacin. Con la seleccin proporcional a la aptitud, se pone demasiado nfasis en la explotacin de cadenas altamente aptas, a expensas de hacer exploracin de otras regiones del espacio de bsqueda. Es decir, la evolucin depende de la varianza de la aptitud en la poblacin. Despus de un nmero de generaciones, los individuos en la poblacin son muy similares, no hay verdaderas diferencias en la aptitud, por lo que no se puede hacer ms explotacin, frenando la evolucin.

1.2.3.1.2. Escalizacin Sigma

Para tratar tales problemas, los investigadores de GAs han experimentado con varios mtodos de escalizacin, mtodos para proyectar valores de aptitud bruta en valores esperados, para que el AG sea menos susceptible a la convergencia prematura. Al iniciar una corrida, cuando la desviacin estndar de las aptitudes es normalmente alta, los individuos ms aptos no tendrn desviaciones estndar arriba de la media, y as no se destinarn a compartir la descendencia. Asimismo, en la corrida, cuando la poblacin es normalmente ms convergente y la desviacin estndar normalmente es baja, los individuos ms aptos permanecern fuera, permitiendo que la evolucin pueda continuar.

1.2.3.1.3. Elitismo

Es una adicin a muchos mtodos de seleccin que obliga al A.G. a retener algunos de los mejores individuos, que pueden perderse si no se seleccionan para reproduccin o si se destruyen por el cruce o la mutacin. Muchos investigadores han encontrado que el elitismo mejora significativamente el desempeo del algoritmo gentico simple.

1.2.3.1.4. Seleccin por Clasificacin

La seleccin por clasificacin es un mtodo alternativo, cuyo propsito es tambin impedir la convergencia demasiado rpida. Los individuos de la poblacin se ordenan de acuerdo a la aptitud, y el valor esperado de cada individuo, depende de su clasificacin ms que de su aptitud absoluta. En este caso, no hay necesidad de hacer una escala de aptitud, puesto que las diferencias de aptitud absoluta pueden llevar a problemas de convergencia. Entre sus desventajas esta en que en algunos casos puede ser importante saber que un individuo est bastante lejos en aptitud que su competidor ms cercano. La formacin de clases evita darle a los ms lejanos, compartir 20

mucho la descendencia, con un grupo pequeo altamente apto, y as reducir la presin de seleccin, cuando la varianza de la aptitud es alta. Tambin mantiene la presin de seleccin cuando la varianza es baja: la relacin de valores esperados de individuos en el rango i e i + 1, ser la misma si sus diferencias en la aptitud absoluta son altas o bajas.

1.2.3.1.5. Seleccin por Torneo

Los mtodos proporcionales a la aptitud descritos anteriormente, requieren dos pasos a travs de la poblacin en cada generacin: un paso para calcular la aptitud media, y otro paso, para calcular el valor esperado de cada individuo. El escalamiento por clasificacin, requiere el ordenamiento de toda la poblacin por clase, un procedimiento que potencialmente consume mucho tiempo. La seleccin por torneo es similar a la seleccin por clasificacin, en trminos de presin de seleccin, pero es computacionalmente ms eficiente y ms apropiada para la implementacin paralela. Se escogen aleatoriamente dos individuos de la poblacin. Luego se escoge un nmero aleatorio r entre 0 y 1. Si r < k, (donde k es un parmetro, por ejemplo 0.75), se selecciona el ms apto de los dos individuos para ser padre; de otra manera se selecciona el individuo menos apto. Luego se devuelven los dos a la poblacin original y se pueden seleccionar otra vez.

1.2.3.2. Operadores Genticos

La tercera discusin que se debe adelantar en la implementacin de un A.G. es qu operadores genticos va a usar. La decisin depende en primer lugar de la codificacin definida y en segundo lugar de la funcin de aptitud. Se discuten aqu el cruce y la mutacin, especialmente en el contexto de codificacin con cadenas de bits.

1.2.3.2.1. Cruce

Se puede decir que es la caracterstica principal de un AG. El cruce en un solo punto es la forma ms comn y simple. La idea es combinar bloques de construccin, de diferentes cadenas. Aunque el cruce en un solo punto tiene algunos defectos como es el del llamado "sesgo posicional" en el que los segmentos que se intercambian entre los dos padres siempre contienen los puntos extremos de las cadenas. Otro problema es que los esquemas con longitudes definidas largas tienen una probabilidad alta de destruccin. Para reducir el sesgo posicional, muchos practicantes de GAs usan cruce de dos puntos en el cual se escogen aleatoriamente dos posiciones y se intercambian los segmentos entre ellas. El cruce de dos puntos daa con menor probabilidad esquemas con longitudes definidas largas y puede combinar ms esquemas que el cruce de un solo punto. Adems, los segmentos que se intercambian no necesariamente contienen los puntos extremos de las cadenas. Tambin hay esquemas que el cruce de dos puntos no puede combinar.

21

Algunos tipos de codificacin requieren operadores de cruce y mutacin especficamente definidos, como en el caso de la programacin gentica cuya codificacin es en rbol, o para solucin de problemas de programacin lineal. Los comentarios anteriores suponen que la razn de ser del cruce es la habilidad de recombinar esquemas altamente aptos. Se podra preguntar si no se debe considerar la posibilidad de que el cruce sea realmente til por alguna razn completamente diferente, por ejemplo, como un operador de "macromutacin" que simplemente permite grandes saltos en el espacio de bsqueda, este es un aspecto abierto en la investigacin de GAs.

1.2.3.2.2. Mutacin

Un punto de vista comn en la comunidad de GAs, que viene del libro de Holland, Adaptation in Natural and Artificial Systems, es que el cruce es el principal instrumento de variacin e innovacin en los GAs, y la mutacin como una garanta de que no haya una permanente fijacin en cualquier posicin particular, jugando as un papel secundario. Esto difiere de las posiciones tradicionales de otros mtodos de computacin evolucionaria, como la programacin gentica, en la cual la mutacin aleatoria es la nica fuente de variacin. Sin embargo, la aparicin del papel de la mutacin esta cambiando en la medida en que la comunidad de GAs, trata de comprender como los GAs solucionan problemas complejos. Se han efectuado algunos estudios comparativos sobre el poder de la mutacin contra el cruce. Se ha verificado formalmente que, mientras la mutacin y el cruce tienen la misma habilidad de "destruir" esquemas existentes, el cruce es un "constructor" ms robusto de nuevos esquemas. Tambin se arguye que en muchos casos, la estrategia de subir la colina trabaja mejor que un AG con cruce y que "el poder de la mutacin se ha subestimado en los GAs tradicionales". La eleccin no es entre cruce o mutacin sino el balance entre cruce, mutacin y seleccin ya que todo es importante. El balance correcto tambin depende de la funcin de aptitud y de la codificacin Adems, el cruce y la mutacin varan en utilidad relativa en el curso de una corrida.

1.3. PROGRAMACION GENETICA

1.3.1. Introduccin

La programacin gentica es una especializacin de los Algoritmos Genticos, en la cual las estructuras computacionales que sufren la adaptacin son en si mismas programas de computador. Basados en la teora Darviniana de la aptitud, se aplica esta por medio de operadores genticos especializados que generalizan la recombinacin sexual y la mutacin. Adems, las estructuras sobre las que se aplican dichos operadores son programas jerrquicos con variacin dinmica en forma y tamao representados a su vez en estructuras de datos en rbol[1]. El espacio de bsqueda en la Programacin Gentica es el espacio de todos los posibles programas de computador compuestos de funciones y terminales apropiados al dominio del problema.

22

Las funciones pueden ser operaciones aritmticas estndar, operaciones de programacin estndar, funciones matemticas estndar, funciones lgicas, o funciones especificas del dominio. La Programacin Gentica es la evolucin directa de programas de computador[3]. As, en casi todos los casos el material gentico que est evolucionando es en cierto sentido ejecutable. Generalmente las estructuras son interpretadas, a veces en un lenguaje idntico o muy parecido a un lenguaje de computacin existente, a veces en un lenguaje diseado para el problema a mano. Sin embargo, en casi todos los casos hay un concepto de ejecucin del material gentico, por algn interpretador, con el objeto de ver el comportamiento de la funcin deseada, a partir de la cual se obtiene la aptitud.
1.3.2. Seleccin del Lenguaje de Programacin

Todos los programas de computador, estn escritos en Visual Basic, C++, cdigo de ensamble, o cualquier otro lenguaje de programacin (estructurado u orientado a objetos), estos pueden verse como secuencias de aplicaciones de funciones (operaciones) a argumentos (valores)[1]. Los compiladores usan este hecho la primera vez que un programa es compilado, para traducirlo en un rbol de anlisis gramatical; para luego convertir dicho rbol en instrucciones ms elementales de cdigo de ensamble que son las realmente interpretadas por el computador. Sin embargo, puesto que inicialmente la Programacin Gentica crea aleatoriamente programas de computador y luego los manipula genticamente, la Programacin Gentica se puede implementar en forma directa en un lenguaje de programacin que permita su fcil manipulacin como datos (rboles) y luego permitan que esos datos creados recientemente se puedan ejecutar como programas. Por estas dos razones el lenguaje de programacin LISP (LISt Processing), es especialmente apropiado para la Programacin Gentica. Sin embargo, se debe reconocer que la Programacin Gentica no requiere el LISP para su implementacin y de ninguna manera se basa en LISP o es dependiente de LISP. No obstante, aunque varios investigadores realmente no usan LISP para escribir sus programas, la mayora encuentra conveniente usar el estilo del LISP para presentar y disear programas evolucionados por Programacin Gentica[3]. LISP tiene solo dos tipos de entidades: tomos y listas. La constante 7 y la variable TIEMPO son ejemplos de tomos en LISP. En LISP se escribe una lista como una coleccin ordenada de elementos dentro de un par de parntesis. Ejemplos de listas son (dos + tres) y (+ 1 2). Tanto las listas como los tomos en LISP se llaman expresiones simblicas (S-expresiones). La S-expresin es la nica forma sintctica en LISP puro[1]. No hay distincin sintctica entre programas y datos en LISP. En particular, todos los datos en LISP son S-expresiones y todos los programas son S-expresiones. El sistema LISP trabaja evaluando todo lo que ve. Cuando LISP ve un tomo constante (por ejemplo, 7) lo evala en s mismo, y un tomo variable (por ejemplo, TIEMPO), LISP evala el valor corriente de la variable. Cuando LISP ve una lista, evala la lista (cualquier cosa al lado del parntesis izquierdo) como una funcin que causa la aplicacin de esa funcin a los resultados de la evaluacin de los elementos restantes de la lista. Si un argumento es un tomo constante o un 23

tomo variable, la evaluacin es inmediata; sin embargo, si el argumento es una lista, la evaluacin de dicho argumento incluye una aplicacin recursiva de los pasos anteriores. Por ejemplo, en la S-expresin LISP (+ 2 3), la funcin suma aparece al inicio del parntesis izquierdo. La S-expresin (+ 2 3) hace un llamado para que se aplique la funcin adicin + a los dos argumentos (es decir, los tomos constantes 2 y 3). Puesto que ambos argumentos son tomos, ellos se pueden evaluar directamente en sus valores (es decir, 2 y 3). De esta manera, el valor retornado como resultado de la evaluacin de toda la S-expresin (+ 2 3) es 5. Si cualquiera de los argumentos en una S-expresin, es en s misma una lista, en lugar de ser tomos constantes y variables que se pueden evaluar directamente, primero LISP evala estos argumentos. En Common LISP, esta evaluacin se hace en forma recursiva y primero en profundidad. Por ejemplo, la S-expresin (+ (* 2 3) 4) hace un llamado para que se aplique la funcin adicin + a los dos argumentos, nominalmente a la S-expresin (* 2 3) y al tomo constante 4. Este argumento (* 2 3) hace un llamado para que se aplique la funcin * a los dos tomos constantes 2 y 3, obteniendo 6, y la evaluacin de la S-expresin completa (+ 6 4) es 10. Las S-expresiones LISP son ejemplos de notacin prefija. Fortran, Pascal y C son similares a la notacin matemtica comn infija, de manera que el programa LISP anterior podra escribirse en esos lenguajes como 2 * 3 + 4. Por ejemplo, con la S-expresin LISP: (+ 1 2 (IF (> TIEMPO 10) 3 4)) En la S-expresin (> TIEMPO 10), la relacin > se ve como una funcin y > se aplica al tomo variable TIEMPO y al tomo constante 10. La S-expresin (> TIEMPO 10) evala entonces si es TRUE (verdadero) o NILL (Falso), dependiendo del valor corriente del tomo variable TIEMPO. El operador condicional IF se ve entonces como una funcin que se aplica a tres argumentos: (> TIEMPO 10), el valor lgico que retorna (TRUE o NILL); el tomo constante 3; y el tomo constante 4. Si su primer argumento se evalo en TRUE (ms precisamente, cualquier valor diferente a NILL), la funcin IF retorna el resultado de evaluar su segundo argumento, (es decir, el tomo constante 3), pero si su primer argumento se evalo en NILL, la funcin IF retorna el resultado de evaluar su tercer argumento (es decir, el tomo constante 4). As, la S-expresin evala 6 o 7, dependiendo de que el valor del tomo variable TIEMPO sea o no mayor de 10. La mayora de los lenguajes de programacin crean formas sintcticas y tipos de instrucciones diferentes para funciones tales como *, >, e IF mientras que LISP trata todas estas funciones en la misma forma.

24

Figura 1 La S-expresin LISP (+ 1 2 (IF (> TIEMPO 10) 3 4)) dibujada como un rbol con los nodos rotulados y las ramas ordenadas[3]. Cualquier S-expresin LISP se puede representar grficamente como un rbol rotulado con ramas orientadas. La Figura 1 muestra el rbol de anlisis gramatical (rbol del programa) correspondiente a la S-expresin descrita anteriormente. En esta representacin grfica, los tres puntos internos del rbol se rotulan con las funciones (es decir, +, IF, y >). Los seis puntos externos, las hojas del rbol, se rotulan con los terminales (es decir, el tomo variable TIEMPO, y los tomos constantes 1, 2, 10, 3 y 4). La raz del rbol se rotula con la funcin que aparece ms a la izquierda del parntesis izquierdo de la S-expresin (es decir, el +). Obsrvese que esta forma de rbol de una S-expresin LISP es equivalente al rbol de anlisis gramatical, que muchos compiladores construyen internamente para representar un programa de computador dado. Una caracterstica importante de LISP es que todos los programas de computador LISP tienen solo una forma sintctica (es decir, la S-expresin). Los programas del lenguaje de programacin LISP son S-expresiones, y una S-expresin es, en efecto, el rbol de anlisis gramatical del programa.

1.3.2.1 Por Que LISP

A continuacin se enumeran algunas caractersticas por las cuales el lenguaje LISP es el ms usado y adecuado para la implementacin de la Programacin gentica[1][3]: En el lenguaje LISP, ambos, programas y datos tienen la misma forma: S-expresiones. As, esto es posible y conveniente para tratar un programa en una poblacin gentica como dato de tal forma que este pueda ser manipulada genticamente. Adems es conveniente para inmediatamente ejecutar el resultado de la manipulacin como un programa. La anterior forma comn, de programas y datos en LISP (las S-expresiones) es equivalente al rbol sintctico para el programa de computador. A pesar de su apariencia exteriormente 25

diferente y sintctica, muchos lenguajes de compilacin internamente convierten en tiempo de compilacin un programa dado en un rbol sintctico de capas superpuestas de funciones y terminales de dicho programa. En muchos lenguajes de programacin, este rbol sintctico no es accesible (o por lo menos no convenientemente) al programador. Y, si este fuera accesible este podra tener una apariencia y sintaxis diferente a la de el lenguaje de programacin mismo. Es necesario acceder al rbol sintctico porque lo que se desea es manipular genticamente las partes del programa (sub-rboles del rbol sintctico). LISP brinda la forma conveniente de acceso a este rbol sintctico, porque la S-expresin es en s misma un rbol sintctico. La funcin de evaluacin provee una forma muy sencilla de ejecutar un programa que fue creado o manipulado genticamente. LISP facilita la programacin de estructuras que pueden cambiar dinmicamente en tamao y forma, sin restricciones de tamao ni almacenamiento. Es importante notar que lo que se utiliza no es como tal lenguaje LISP sino, comportamiento que este presenta con sus datos en forma de S-expresiones. el

1.3.3. Caractersticas de la Programacin Gentica

Se puede observar que el caso de la programacin gentica, no es ms que una especializacin del algoritmo gentico simple expuesto anteriormente, el cual, replanteado para la programacin gentica, tendra la siguiente forma[3]: Genere una poblacin inicial de composiciones aleatorias de funciones y terminales del problema (programas de computador). Mientras no se cumpla a satisfaccin el criterio de terminacin Haga Ejecute cada programa de la poblacin y asgnele de acuerdo a qu tan bien soluciona el problema un valor de aptitud. Cree una nueva poblacin de programas aplicando los dos operadores primarios (cruce y mutacin) con algn criterio de seleccin definido. Copie los programas existentes a la nueva poblacin. Cree nuevos programas por medio de la generacin aleatoria. Fin mientras El programa ms apto de la poblacin al momento de la terminacin del ciclo anterior, es designado como el resultado de la programacin gentica. Al analizar el algoritmo anterior podemos entonces comenzar a describir el paradigma de la programacin gentica, en trminos de: 26

las estructuras que sufren adaptacin, las estructuras iniciales, la medida de aptitud que evala las estructuras, las operaciones que se realizan para modificar las estructuras, el estado (memoria) del sistema en cada fase, el mtodo para designar un resultado, el mtodo para terminar el proceso y los parmetros que controlan el proceso.

1.3.3.1. Las Estructuras que Sufren Adaptacin

En cada sistema adaptativo o de aprendizaje, alguna estructura o estructuras estn sufriendo adaptacin. Para los algoritmos no-genticos adaptativos, la estructura que sufre adaptacin es tpicamente un solo punto en el espacio de bsqueda del problema. Para los algoritmos genticos convencionales y la programacin gentica, las estructuras que sufren adaptacin son puntos individuales, en una poblacin de puntos del espacio de bsqueda del problema. Es decir, la aproximacin gentica involucra una bsqueda paralela. Las estructuras individuales que sufren adaptacin en la programacin gentica son programas de computadora jerrquicamente estructurados. El tamao, forma, y complejidad de stos programas de computadora pueden cambiar dinmicamente durante el proceso. El juego de posibles estructuras en el paradigma de la programacin gentica es el juego de todas las posibles composiciones de funciones que pueden formarse recursivamente del juego disponible de Nfunc funciones del conjunto fijo F = {f1, f2,..., fNfunc} y el juego disponible de Nterm trminos terminales del conjunto fijo de terminales T = {a1, a2,..., aNterm}. Cada funcin particular f en F toma un nmero z(f) de argumentos b1, b2,, bz(f). Las funciones en el conjunto de funciones pueden ser: funciones aritmticas (+, -, *, etc.), funciones matemticas (como Seno, Coseno, Exp, etc.), operadores booleanos (como AND, OR, NOT), operadores lgicos (como If-Then-Else), operadores iterativos (como Do-Until), funciones que permiten recursin y funciones de dominio especifico.

Las terminales son tpicamente cualquiera tomos constantes (como el nmero 3) o los tomos variables (representando, quizs, las entradas, sensores, o las variables de estado de algn sistema). Considrese el conjunto de las funciones F = {AND, OR, NOT} 27

y el conjunto de terminales T = {D0, D1}, donde D0 y D1 son tomos Booleanos variables que sirven como argumentos para las funciones. Combinamos el conjunto de funciones y terminales en el conjunto C como sigue: C = F T = {AND, OR, NOT, D0, D1}. Ahora considere la funcin de igualdad con dos argumentos. Esta funcin devuelve TRUE (Verdadero) si los dos argumentos son iguales; por otra parte, esta funcin devuelve NILL (Falso). Esta funcin booleana puede expresarse en forma normal disyuntiva (DNF) y representada por la S-expresin LISP: (OR(AND (NOT D0) (NOT D1)) (AND D0 D1)). El rbol ordenado que corresponde a la S-expresin anterior para la funcin de paridad igual con dos argumentos se muestra en la Figura 2.

Figura 2 Arbol LISP correspondiente a la S-expresin (OR (AND(NOT D0) (NOT D1)) (AND D0 D1)) En esta descripcin grfica, se etiquetan los cinco puntos interiores del rbol con funciones (ej. OR, AND, NOT, NOT, y AND). Los cuatro puntos externos (hojas) del rbol se etiquetan con terminales (ej. Los tomos Booleanos variables D0, D1, D0, y D1, respectivamente). La raz del rbol se etiqueta con la funcin que aparece en parntesis izquierdo extremo de la S-expresin LISP (es decir OR). El espacio de bsqueda para el paradigma de la programacin gentica es el hiperespacio de Sexpresiones LISP que pueden ser creadas recursivamente por composiciones de las funciones y trminos disponibles para el problema. Este espacio de bsqueda puede, equivalentemente, ser visto como el hiperespacio de rboles con ramas ordenadas con puntos interiores etiquetados con las funciones disponibles y los puntos externos (hojas) etiquetados con las terminales disponibles. Las estructuras que sufren adaptacin en el paradigma de la programacin gentica son diferentes de las estructuras que sufren adaptacin en el algoritmo gentico convencional que opera en cadenas. Las estructuras que sufren adaptacin en el paradigma de la programacin gentica son estructuras jerrquicas. 28

Usando la programacin gentica, el conjunto de terminales y de funciones debe seleccionarse para satisfacer dos requisitos, a saber, el de cierre y suficiencia.

1.3.3.1.1. Cierre

Acerca de la propiedad del cierre, cada funcin en el conjunto de funciones debe ser bien definida para cualquier combinacin de argumentos que pueda encontrarse. Estos valores de argumento pueden venir de una terminal o una funcin. Por ejemplo, si el conjunto de funciones es el de las funciones booleanas AND y OR, y el conjunto de terminales slo consiste en variables booleanas que pueden asumir slo los valores de TRUE o NILL, entonces la propiedad del cierre se satisfar. Por otro lado, si la operacin aritmtica de divisin est en el conjunto de funciones junto con trminos que pueden asumir el valor numrico cero, la propiedad del cierre no se cumplir a menos que algn arreglo se haga al tratar con la situacin cuando se intenta la divisin por cero. Si la propiedad del cierre no prevalece, es necesario plantear alternativas como: (1) desechar a los individuos que no evalan un resultado dentro del dominio deseado o (2) asignando alguna multa a la aptitud de tales individuos y procediendo de alguna manera.

1.3.3.1.2. Suficiencia

Acerca de la suficiencia, el conjunto de funciones y terminales que se usan en un problema particular deben ser seleccionadas para ser capaces de resolver el problema. Por ejemplo, uno no podra inducir la Tercera Ley de Kepler para los periodos de los planetas alrededor del sol si el conjunto de terminales contiene slo el dimetro de cada planeta (como opuesto a su distancia del sol) o si el conjunto de funciones tuviera slo definidas la suma y la substraccin (en lugar de las funciones necesarias para declarar la Tercera Ley). El usuario de la programacin gentica debe saber o creer que alguna composicin de funciones y terminales que l proporciona pueden dar una solucin al problema. En algunos dominios (ej. Funciones booleanas), los requisitos son bien conocidos. Por ejemplo, quitando la funcin NOT del conjunto de funciones F = {AND, OR, NOT} crea un conjunto de funciones que no es suficiente para expresar muchas funciones booleanas, incluyendo, por ejemplo, la funcin de igualdad de dos terminales. La eleccin del conjunto de funciones y terminales disponibles, por supuesto, afecta el carcter de las soluciones que pueden lograrse directamente. Las funciones y terminales disponibles forman la base para las potenciales soluciones generadoras.

1.3.3.2. Las Estructuras Iniciales

Las estructuras iniciales en la programacin gentica consisten en los individuos en la poblacin inicial de S-expresiones individuales para el problema. 29

La generacin de cada S-expresin individual en la poblacin inicial es hecha generando al azar un rbol, con nodos etiquetados y ramas ordenadas que representan la S-expresin. Inicialmente se selecciona una de las funciones al azar del conjunto fijo F (usando una distribucin uniforme) para ser la etiqueta para la raz del rbol. Ntese que la seleccin de etiqueta para la raz del rbol se restringe a las funciones fijas F puesto que se desea generar una estructura jerrquica, y no una estructura degenerada que consiste en un solo trmino. Por ejemplo, en la Figura 3, la funcin + (tomando dos argumentos) se seleccion de un conjunto de funciones F como la etiqueta para la raz del rbol donde z(f) es el nmero de argumentos tomado por la funcin f, se crea para radiar a partir de ese punto. Entonces, para cada lnea de radiado, un elemento se selecciona al azar para ser la etiqueta para el punto de finalizacin de dicha lnea de radiado.

Figura 3 La generacin de un rbol aleatorio podra empezar con etiquetar la raz del rbol con la funcin +. Si una funcin es escogida para ser la etiqueta para cualquier punto de finalizacin, el proceso generador contina entonces recursivamente como se describi anteriormente. Por ejemplo, en la Figura 4, la funcin * del conjunto combinado C = F T de funciones y terminales se seleccion como la etiqueta del punto interior al final de la primer (Lado izquierdo) lnea de radiado del punto con la funcin +. Esta funcin * toma dos argumentos para las que se muestran dos lneas que radian fuera del punto con la funcin *.

Figura 4 La generacin de un rbol aleatorio podra continuar con etiquetar un punto interior con la funcin *. Por otro lado, si una terminal es elegida para ser la etiqueta para cualquier punto, ese punto se vuelve un punto final (hoja) del rbol y el proceso generador termina para ese punto. Por ejemplo, en la Figura 5, el terminal A del conjunto T de terminales fue seleccionado para ser la etiqueta de la primera lnea radiada del punto etiquetado con la funcin *.

30

Figura 5 La generacin de un rbol aleatorio podra continuar con etiquetar un punto externo con la terminal A. El proceso generador puede llevarse a cabo de maneras diferentes que producen rboles aleatorios iniciales de diferentes tamaos y formas. El mtodo generador que se comporta mejor sobre un amplio rango de problemas es un mtodo llamado "Inclinacin media'', en la cual se produce una mezcla de rboles de varios tamaos y formas. Este mtodo generador involucra la creacin de un nmero igual de rboles cuya profundidad est entre dos y alguna profundidad mxima. La profundidad de un rbol es la longitud del camino ms largo de la raz a un punto final (hoja). Entonces, para cada valor de la profundidad, se crea un 50% de los rboles de esa profundidad en cada uno de dos maneras, a saber: 50% de los rboles de la profundidad especificada son "completos'' en que la longitud de los caminos entre cada punto final (hoja) y la raz es igual al mximo. Esto se logra restringiendo la seleccin aleatoria de la etiqueta para los puntos del rbol a profundidades ms pequeas que el mximo al conjunto de funciones F y restringiendo la seleccin aleatoria de la etiqueta para los puntos a profundidades que igualan al mximo al conjunto de terminales T. 50% de los rboles de profundidad especificada son de forma variable en los que la longitud de caminos entre una hoja y la raz no es mayor que el mximo especificado. Esto se cumple haciendo la seleccin aleatoria de la etiqueta para los puntos del rbol a profundidades ms pequeas que el mximo del conjunto combinado C = F T que consiste en la unin del conjunto de funciones F y el conjunto de terminales T, mientras se restringe la seleccin aleatoria de la etiqueta para los puntos a profundidades iguales al mximo al conjunto de terminales T.

Normalmente se utiliza una distribucin de probabilidad uniforme para las selecciones anteriormente descritas. Los individuos duplicados son improductivos, implicando gasto de recursos computacionales y reduccin de la diversidad gentica de la poblacin. En el paradigma de la programacin gentica, se crean a menudo individuos aleatorios dobles cuando el tamao del rbol es pequeo o cuando el tamao del conjunto de terminales es tan grande como el conjunto de funciones.

1.3.3.3. La Aptitud

A cada individuo en una poblacin se le asigna un valor de aptitud numrico como resultado de su interaccin con su ambiente. Existen cuatro medidas diferentes de aptitud, a saber[3]: 31

La aptitud cruda. La aptitud regularizada. La aptitud ajustada. La aptitud normalizada.

La aptitud cruda es la medida de aptitud que se declara en la terminologa natural del propio problema. La aptitud cruda normalmente es, pero no siempre, evaluada sobre un conjunto de casos de aptitud. Estos casos de aptitud mantienen una base para evaluar la aptitud de las Sexpresiones en la poblacin sobre diferentes situaciones representativas para las que un rango de valores de aptitud crudos numricos diferentes pueda obtenerse. Los casos de aptitud son tpicamente una muestra finita pequea del espacio del dominio (qu normalmente es muy grande o infinito). Por consiguiente, los casos de aptitud deben ser en conjunto representativo del espacio del dominio porque ellos forman la base para generalizar los resultados obtenidos al espacio del dominio. La definicin de aptitud cruda depende del problema. Para muchos problemas, la aptitud cruda puede definirse como la suma de las distancias (es decir los errores), tomando todos los casos de aptitud, entre el punto en el espacio del rango devuelto por la S-expresin para el conjunto de argumentos y el punto correcto en el espacio del rango para el caso de aptitud particular. La Sexpresin puede ser evaluada como:

r(i, t) =

S(i,
j =1

NE

j) - C(j)

booleana, entera, real, compleja, o simblica. Si la S-expresin es evaluada como entera o real, la suma de distancias es la suma de valores absolutos de las diferencias (o, si se desea, la suma de los cuadrados de las diferencias) entre los nmeros involucrados. Cuando la aptitud cruda es el error, la aptitud cruda r(i,t) de una S-expresin i en la poblacin de tamao M a cualquier paso generacional t es: donde S(i,j) es el valor devuelto por la S-expresin i para el caso de aptitud j (de NE casos) y donde C(j) es el valor correcto por el caso de aptitud j. Si la S-expresin es evaluada como booleana o simblica, la suma de distancias es equivalente al nmero de desigualdades. Para otros problemas, la aptitud cruda puede ser otro elemento distinto al error. Por ejemplo, cantidad de puntos anotados, beneficio logrado, cantidad de sub-tareas realizadas a satisfaccin. Note que porque la aptitud cruda se declara en la terminologa natural del problema, el mejor valor puede ser el ms pequeo (como cuando la aptitud cruda es el error) o ms grande (como cuando la aptitud cruda es el beneficio logrado, etc.). La aptitud regularizada s(i,t) reitera la aptitud cruda para que un valor numrico ms bajo sea mejor. Si un valor ms bajo de la aptitud cruda es mejor (ej. cuando la aptitud cruda representa el error), entonces la aptitud regularizada:

s(i,t) = r(i,t)
32

Si un valor ms alto de la aptitud cruda es mejor (ej. Cuando el alimento es ser ingerido), la aptitud regularizada iguala el mximo el posible valor de aptitud cruda rmax menos la aptitud cruda observada. Es decir:

s(i,t) = rmax - r(i,t)

Se define ahora la aptitud ajustada a(i,t). La medida de aptitud ajustada a(i,t) se computa de la aptitud regularizada s(i,t). As, la aptitud ajustada a(i,t) es:

a(i, t) =

1 (1 + s(i, t))

donde el s(i,t), es la aptitud regularizada para el individuo i al tiempo t. La aptitud ajustada se encuentra en el rango [0...1]. La aptitud regularizada difiere de la ajustada en que esta ltima es ms grande para los mejores individuos en la poblacin. Si ningn limite superior rmax es conocido (haciendo imposible el calculo de la aptitud regularizada), este paso puede omitirse y puede ajustarse la aptitud directamente de la aptitud cruda. La aptitud ajustada tiene el beneficio de exagerar la importancia de diferencias pequeas en el valor de la aptitud regularizada como estos valores comienzan acercndose a cero en generaciones posteriores. La aptitud ajustada es especialmente beneficiosa si la aptitud regularizada alcanza el valor cero cuando una solucin perfecta al problema es encontrada (ej. Como en problemas de la regresin simblica donde un error igual a cero denota una aptitud perfecta). La aptitud normalizada n(i,t) se computa del valor de la aptitud ajustada a(i,t). As, la aptitud normalizada es:

n (i, t ) =

a (i, t )

a (k , t )
k =1

La aptitud normalizada tiene tres caractersticas deseables: Se encuentra en el intervalo [01]. Es ms grande para los mejores individuos en la poblacin. La suma de los valores de aptitud normalizados es uno.

Tambin es posible que la funcin de aptitud le d algn peso a los factores secundarios. Por ejemplo a la eficacia de la S-expresin.

33

1.3.3.4.Operaciones para la Modificacin de Estructuras

Las dos operaciones primarias para la modificacin de estructuras que sufren adaptacin en la programacin gentica son (1) reproduccin Darviniana proporcional a la aptitud y (2) el cruce (recombinacin sexual).

1.3.3.4.1. Reproduccin

La operacin de reproduccin para la programacin gentica es el motor bsico de la reproduccin Darviniana y la supervivencia del ms apto. Cada vez que esta operacin se efecta, opera en slo una S-expresin padre y produce slo una S-expresin descendiente. Es decir, es una operacin asexual. El funcionamiento de reproduccin consiste en dos pasos. Primero, una sola S-expresin se selecciona de la poblacin segn alguna regla de seleccin basada en aptitud. Luego, el individuo se copia de la poblacin actual a la nueva poblacin (es decir la nueva generacin). Hay muchas reglas de la seleccin basadas en aptitud. La regla de la seleccin ms popular es la seleccin ruleta. Cuando se utiliza la seleccin por ruleta en la operacin de reproduccin, si f(si(t)) es la aptitud del individuo si en la generacin t, entonces, cada vez que la operacin de reproduccin se realiza, cada individuo en la poblacin tiene una probabilidad de ser copiada en la prxima generacin as:

f (s
j =1

f ( s i ( t ))
j

( t ))

Cuando el operador de reproduccin ha sido aplicado con la seleccin por ruleta como regla de seleccin, se llama reproduccin proporcional a la aptitud. Ntese que el padre permanece en la poblacin mientras la seleccin se ha llevado a cabo durante la generacin actual. Es decir pueden seleccionarse padres, y en general, se seleccionan, ms de una vez para la reproduccin durante la generacin actual. De hecho, la proporcin diferencial de supervivencia y reproduccin para ms individuos aptos es una parte esencial de algoritmos genticos.

1.3.3.4.2. Cruce (Recombinacin)

El operador de cruce (recombinacin) para la programacin gentica crea una variacin en la poblacin, produciendo nueva descendencia que consiste en partes tomada de cada padre. El funcionamiento del cruce comienza con dos S-expresiones padres y produce una descendencia de dos S-expresiones. Es decir, es un operador sexual. En general, por lo menos un padre es escogido de la poblacin con una probabilidad igual a su aptitud normalizada. 34

El operador comienza seleccionando independientemente y usando una distribucin de probabilidad uniforme, un punto al azar en cada padre para ser el punto de cruce para ese padre. Ntese que el nmero de puntos en los dos padres no es tpicamente igual porque las S-expresiones en la poblacin son de varias formas y tamaos. El fragmento de cruce para un padre en particular es el sub-rbol cuya raz es punto de cruce seleccionado para ese padre y donde el sub-rbol consiste en el sub-rbol entero que queda debajo del punto de cruce, desde el punto de vista de una S-expresin, el fragmento de cruce es la sub-lista que empieza en el punto de cruce. La primera S-expresin descendiente es producida eliminando el fragmente del primer padre e insertando el fragmento de cruce del segundo padre al punto de cruce del primer padre. La segunda descendencia se produce de una manera simtrica. Puede observarse como el operador de cruce es sintcticamente legal para cualquiera dos S-expresiones y dos puntos cualquiera de cruce. Por ejemplo, considrese las dos S-expresiones LISP mostradas en la Figura 6. Las funciones que aparecen en estas dos S-expresiones son las funciones booleanas AND, OR, y NOT. Las terminales son los argumentos booleanos D0 y D1. Cada punto de las dos S-expresiones est numerado de acuerdo con el recorrido del rbol.

Figura 6 Dos S-expresiones LISP. Equivalentemente, en trminos de S-expresiones LISP, los dos padres son: (OR (NOT D1) (AND D0 D1)) y (OR (OR D1 (NOT D0)) (AND (NOT D0) (NOT D1)) Suponga que el segundo punto (de los seis del primer padre) se selecciona al azar como el punto de cruce para el primer padre. Por tanto el punto de cruce en el primer padre es la funcin NOT. Tambin suponga que el sexto punto (de los 10 puntos del segundo padre) se selecciona como el punto de cruce del segundo padre. Por consiguiente el punto de cruce corresponde a la funcin AND. Las porciones subrayadas de las dos S-expresiones padres son los fragmentos a cruzar, la figura 7, muestra estos dos fragmentos.

35

Figura 7 Dos fragmentos seleccionados para cruce de los padres de la Figura 6 La Figura 8 muestra la descendencia resultado del cruce.

Figura 8 Descendencia producida por el operador de cruce que usa a los padres de Figura 6 y los fragmentos de cruce de la figura 7. Ntese que el primer descendiente es una solucin perfecta para la funcin de paridad igual, a saber, (OR (AND (NOT D0) (NOT D1)) (AND D0 D1)). El segundo descendiente es: (OR (OR D1 (NOT D0)) (NOT D1)). Obsrvese adems que puesto que los sub-rboles enteros son intercambiados, y debido a la propiedad del cierre de las funciones en si mismas, el operador gentico de cruce (recombinacin) produce una S-expresin LISP sintcticamente correcta como descendencia en todas las situaciones. Adems es importante observar que si un individuo es emparentado con s mismo o con un individuo idntico, la descendencia resultante generalmente ser diferente (porque los puntos de cruce seleccionados son, en general, diferentes para los dos padres). Esto en contraste con los algoritmos genticos convencionales los cuales operan en una cadena de caracteres de longitud fija donde el punto de cruce aplica a ambos padres. Si una terminal se localiza en el punto de cruce en el primer padre, entonces el sub-rbol del segundo padre se inserta a la instancia del primer padre y el trmino del primer padre se inserta a la instancia del sub-rbol en el segundo padre. En este caso, la funcin de cruce tiene a menudo el efecto de aumentar la profundidad de un rbol y disminuir la profundidad del otro. Si se localizan terminales en ambos puntos de cruce seleccionados, la funcin de cruce intercambia 36

estos trminos de rbol a rbol. El efecto del cruce, en este evento, es semejante a una mutacin del punto. As, la mutacin del punto ocasional es una parte inherente de la funcin de cruce. Un mximo el tamao permisible (de la profundidad del rbol) se establece para la descendencia creada por el operador de cruce. Este lmite previene cantidades grandes de tiempo de mquina en S-expresiones sumamente grandes. Por supuesto, si fuese posible ejecutar todos las Sexpresiones individuales en la poblacin en paralelo (como la naturaleza lo hace) de una manera tal que un individuo que requiera un calculo muy grande, no afecte los recursos necesarios para el resto de la poblacin. Si un cruce entre dos padres creara una descendencia de tamao imprevisible, el operador de cruce se aborta para esa descendencia y el primero de los padres se escoge ser reproducido arbitrariamente en la nueva poblacin.

1.3.3.5. El Estado del Sistema

El estado del sistema de programacin gentica a cualquier punto durante el proceso slo consiste en la poblacin actual de individuos en la poblacin. No hay ninguna memoria adicional.

1.3.3.6. Designacin del Resultado

El nico mejor individuo en la poblacin en el momento de la terminacin de la programacin gentica se designa tpicamente como el resultado producido por el algoritmo. Este mtodo de designacin de los resultados a veces se llama `` el ganador toma todo''. Es de anotar que no necesariamente el mejor individuo se encuentre presente en la poblacin en el momento de la terminacin a menos que algn esfuerzo especfico se lleve a cabo para conservar a dicho individuo (por ejemplo aplicando una estrategia elitista). Alternamente, la poblacin en su totalidad en el momento de la terminacin de la programacin gentica puede designarse como el resultado producido por l.

1.3.3.7. Terminacin

En cuanto a la terminacin, la programacin gentica es paralela a la naturaleza en que es un proceso continuo. Como un hecho prctico, la programacin gentica termina cuando un nmero de mximo de Ngen de generaciones ha sido alcanzado o cuando algn criterio de terminacin ha sido satisfecho. Un criterio de terminacin puede ser que la aptitud regularizada de algn individuo en la poblacin sea igual a cero o est dentro de una vecindad preestablecida cercana a cero.

37

1.3.3.8. Parmetros de Control

La programacin gentica es controlada por varios parmetros; incluye dos parmetros mayores y cinco parmetros menores. Los dos parmetros mayores que se usan para controlar el proceso son el tamao de la poblacin M y el nmero de generaciones Ngen para ser ejecutado. Se usan cinco parmetros menores para controlar el proceso. Dos de ellos controlan la frecuencia con la que se realizan las operaciones genticas; uno de ellos controla el porcentaje de (funcin) puntos escogidos como puntos de cruce; y dos de ellos ayudan a conservar tiempo de computador. 1. el cruce se aplica a un porcentaje de la poblacin en cada generacin (generalmente es de 90%). Es decir, si el tamao de la poblacin es 500, entonces 450 individuos (225 pares) de cada generacin se seleccionan con una probabilidad igual a su aptitud normalizada (con reseleccin permitida) para participar en el cruce. 2. la reproduccin se aplica segn el tipo de aptitud escogido (es generalmente el complemento de el porcentaje aplicado al cruce, p. ej. 10%) a la poblacin en cada generacin. Es decir, si el tamao de la poblacin es 500, se seleccionan 50 individuos de cada generacin con una probabilidad igual a su aptitud (con re-seleccin permitida). 3. Tercero, se asigna una probabilidad de seleccin de puntos internos del rbol para el operador de cruce (generalmente es 90% para los puntos interiores), dejando el resto (p. ej. 10%) para los puntos externos (terminales). 4. Se establece una profundidad mxima (generalmente es de 17) para S-expresiones creadas por cruce. 5. Se establece adems una profundidad mxima (generalmente es de 6) para las S-expresiones generadas aleatoriamente en la poblacin inicial.

1.3.4. Funciones Predefinidas

En el paradigma de la programacin gentica, se presenta un mtodo diseado con el fin de descomponer el problema en subproblemas ms simples, con el fin de ensamblar soluciones a estos dentro de una solucin al problema completo. En el problema que nos atae, estos subproblemas se refieren a la implementacin de funciones booleanas de un nmero determinado de entradas y una sola salida, por ejemplo una funcin XOR de tres o ms entradas, es de gran ayuda para la construccin de el sumador de 3 bits, as, entonces se supone que el usuario pueda definir estas funciones antes de comenzar la ejecucin del algoritmo.
1.3.5. Algoritmo de Dejoung

Este tipo de algoritmo propuesto por Dejong, utiliza poblaciones solapadas con una cantidad definida por el usuario de solapamiento. El algoritmo crea una poblacin de individuos clonando el genoma de la poblacin inicial. Cada generacin, el algoritmo crea una poblacin temporal de individuos, y los adiciona a la poblacin existente, para luego remover los peores individuos de la poblacin, con el fin de regresarla a su tamao inicial. 38

1.4. CIRCUITOS LOGICOS COMBINATORIOS

1.4.1. Definicin

Un circuito lgico combinatorio es un dispositivo que se constituye por un conjunto de combinaciones de compuertas lgicas. En cualquier instante de tiempo, el nivel lgico de la salida depende de la combinacin de los niveles lgicos en las entradas. Un circuito combinatorio no posee memoria, ya que solo depende del valor de las entradas actuales del sistema.
N variables de Entrada

CIRCUITO LGICO COMBINACIONAL

M variables de Salida

Figura 9 Esquema de un circuito lgico combinacional. Un circuito lgico combinatorio puede describirse en cualquier instante de tiempo por medio de una Tabla de Verdad. Una Tabla de Verdad es una matriz de todas las combinaciones posibles de las variables de entrada que se relaciona con las salidas esperadas para cada una de las combinaciones. El nmero de combinaciones posibles est dado por 2N, donde N es el nmero de entradas. Entrada 0 Entrada 1 x y 0 0 0 1 1 0 1 1 Salida z 1 0 0 1

Tabla 1 Combinaciones Posibles Sin embargo, en muchos circuitos, solo un subconjunto de esas combinaciones produce una salida. Adems, de los circuitos lgicos combinatorios, existen los circuitos secuenciales, que se forman por un conjuntos de circuitos combinatorios y elementos de memoria.
N variables de Entrada

CIRCUITO LGICO SECUENCIAL

Elementos de Memoria

M variables de Salida

Figura 10 Esquema de un circuito lgico secuencial. 39

1.4.2. Lgica Binaria

En la lgica binaria se hacen operaciones con variables que pueden tomar nicamente dos valores discretos. Dichos valores pueden denominarse verdadero y falso, 0 y 1. Se conocen como variables booleanas y representan niveles lgicos 0 FALSO BAJO VOLTAJE NO 1 VERDADERO ALTO VOLTAJE SI

Tabla 2 Valores Booleanos Por ejemplo una variable booleana puede representar el nivel de voltaje existente en la entrada de un circuito integrado. (En trminos prcticos, el valor booleano 0 es asignado a voltajes entre 0v y 0.8v, mientras que el valor 1, se encuentra en el rango 2v a 2.5v). En la lgica binaria existen variables booleanas y operaciones booleanas. Las variables por lo general se identifican mediante letras del alfabeto. En esta lgica existen solamente tres operaciones bsicas: 1. Adicin 2. Multiplicacin 3. Complementacin o inversin

1.4.2.1. Adicin Lgica

La tabla de verdad que describe el comportamiento de la adicin lgica se muestra a continuacin: A 0 0 1 1 B 0 1 0 1 X = A+B 0 1 1 1

Tabla 3 Tabla de verdad de la adicin lgica Dicha operacin se representa por medio del smbolo +. Entonces, si X es el resultado de realizar una adicin lgica entre A y B, X se expresa de la siguiente forma: X=A+B La expresin anterior tambin se puede leer como X igual a A OR B. la figura 11 representa el smbolo de la compuerta OR utilizado en la etapa de diseo y documentacin de un circuito. 40

Figura 11 Compuerta OR.

1.4.2.2. Multiplicacin Lgica

La siguiente es la tabla de verdad que describe el comportamiento de la multiplicacin lgica. A 0 0 1 1 B 0 1 0 1 X = AB 0 0 0 1

Tabla 4 Tabla de verdad de la multiplicacin lgica Esta operacin se representa por medio de un punto o por la ausencia de operador. As, si dos variables lgicas A y B se combinan por medio de una multiplicacin lgica (denominada AND), el resultado puede expresarse de la siguiente manera: X=AB Como se observa en la tabla, la operacin de multiplicacin lgica se asemeja a la multiplicacin presente en el lgebra ordinaria, ya que el producto de dos nmeros que pueden tomar valores 0 o 1 solo puede ser 1 si ambos operandos lo son tambin. La figura 12 representa el smbolo de la compuerta AND utilizado en la etapa de diseo y documentacin de un circuito.

Figura 12 Compuerta AND

1.4.2.3. Inversin Lgica

Esta operacin se realiza sobre una sola variable de entrada. La siguiente tabla describe el comportamiento de la inversin lgica.

41

A 0 1 0 1

X = A 1 0 1 0

Tabla 5 Tabla de verdad de la inversin lgica Dicha operacin suele representarse por medio de una barra sobrepuesta a la variable o una comilla a su lado izquierdo. Por ejemplo: X= A Donde X es la salida inversa de la entrada A. Esta operacin se conoce tambin como inversin lgica o NOT. El smbolo utilizado para describir esta operacin es el siguiente (Figura 13):

Figura 13 Negador. Debe notarse que dentro del conjunto de estndares de diseo de circuitos, el crculo representa negacin o inversin de la seal.
1.4.3. Otras Compuertas Lgicas

Como se ha mencionado hasta ahora, las tres compuertas bsicas (operaciones lgicas) son AND, OR y NOT. Con dichas operaciones se puede describir cualquier circuito lgico combinatorio sin importar su complejidad. Sin embargo, para el proyecto que se realiza, se tienen en cuenta otras tres compuertas que pueden simplificar el diseo de un circuito. Estas compuertas se conocen como OR-Exclusiva, NAND y NOR.

1.4.3.1. Compuerta Or Exclusiva

La siguiente tabla de verdad describe el comportamiento de la operacin OR-Exclusiva, que se conoce tambin como XOR o EOR.

42

A 0 0 1 1

B 0 1 0 1

X = AB 0 1 1 0

Tabla 6 Tabla de verdad de la compuerta XOR Si se relacionan las variables A y B por medio de esta operacin, se escribe: X= A B Como se observa en la tabla, en esta operacin se obtiene una salida de 1 cuando las variables de entrada son diferentes. Esta compuerta se obtiene utilizando las operaciones bsicas de la siguiente forma: X=A B = AB + AB El smbolo utilizado en el diseo de circuitos para esta compuerta es el siguiente (figura 14):

Figura 14 Compuerta XOR.

1.4.3.2. Compuerta Nand

La compuerta NAND simplemente es el complemento o el inverso de una funcin AND. Es decir, si: X= A NAND B X=(AB) = (A AND B) La siguiente es la tabla de verdad que describe el circuito: A 0 0 1 1 B 0 1 0 1 X = A NAND B 1 1 1 0

Tabla 7 Tabla de verdad de la compuerta NAND El smbolo utilizado para representar una compuerta NAND en el diseo de circuitos es el siguiente (figura 15): 43

Figura 15 Compuerta NAND.

1.4.3.3. Compuerta Nor

La compuerta NOR se forma del complemento de la salida de una compuerta OR. Por lo tanto, al realizar esta operacin sobre dos variables booleanas A y B se puede escribir: X= A NOR B X=(A+B) = (A OR B) La siguiente es la tabla de verdad que describe el circuito: A 0 0 1 1 B 0 1 0 1 X = A NOR B 1 0 0 0

Tabla 8 Tabla de verdad de la compuerta NOR El smbolo utilizado para representar una compuerta NOR en el diseo de circuitos es el siguiente (figura 16):

Figura 16 Compuerta NOR.

1.4.3.4. Importancia de las Compuertas Nand y Nor

Un aspecto bsico que debe tenerse en cuenta en el diseo de circuitos, es la universalidad de las compuertas NAND y NOR. Todas las expresiones booleanas se forman por la combinaciones de las compuertas bsicas OR, AND y NOT. Sin embargo es posible describir el comportamiento del circuito por medio de compuertas NAND o por medio de compuertas NOR. La figura 17 muestra ejemplos de la relacin existente entre las compuertas NAND y NOR y las compuertas bsicas.

44

Figura 17 Equivalencias para diferentes compuertas. Por lo anterior, en la etapa de implementacin del diseo, usando circuitos integrados NAND y NOR se reduce la cantidad de dispositivos involucrados en el sistema, sin que se pierda la funcionalidad del mismo.
1.4.4. Diseo Analtico de Circuitos Lgicos Combinatorios

Los siguientes son los pasos necesarios para realizar el diseo de circuitos lgicos combinatorios: 1. 2. 3. 4. 5. 6. Describir el problema. Determinar el nmero de variables de entrada y de salida necesarios. Asignar letras que identifiquen las variables Deducir la tabla de verdad que defina completamente el circuito necesario Simplificar funciones Dibujar el diagrama lgico obtenido

La descripcin del problema radica en la exposicin detallada de la funcionalidad que debe tener el circuito. Entonces, el diseador debe indicar cuantas variables (seales) de entrada y salida deben ser utilizadas. Por medios analticos (dada una especificacin completa del problema) se debe deducir la tabla de verdad que refleje fielmente el comportamiento del circuito. Luego, se buscan las relaciones que permitan obtener esas salidas y se simplifican. Por ultimo se documenta el diseo para ser probado e implementado. En la siguiente seccin, se exponen las caractersticas ms importantes de la simplificacin de funciones que se usa en el diseo de circuitos.

45

1.4.4.1. Simplificacin de Funciones

Para realizar el diseo analtico de circuitos lgicos, se debe expresar el comportamiento del sistema por medio de expresiones lgicas que se encuentren en forma de suma de productos. Cada una de las expresiones en una suma de productos, consta de varios trminos AND (producto lgico) que se combinan por medio de operaciones OR (suma lgica). Adems tiene una caracterstica especial: En cada trmino no debe existir inversin lgica de ms de una variable. La simplificacin algebraica de un circuito lgico permite modificar un diseo original para que su implementacin sea ms sencilla y eficiente. Esto se logra en dos etapas: Uso de Mapas de Karnaugh, y teoremas DeMorgan para llevar una descripcin a la forma de suma de productos. Factorizacin matemtica de la expresin.

1.4.4.2. Mapas De Karnaugh

Este mtodo propuesto inicialmente por VEITCH y modificado por KARNAUGH (como se conoce en la actualidad) consiste de un diagrama en forma de tabla donde cada elemento representa un trmino mnimo (es decir, cada uno de los trminos de una expresin que se encuentre en forma de suma de productos). En la prctica, su uso se reduce a circuitos con 6 variables de entrada como mximo. El primer paso para representar un circuito en el mapa de KARNAUGH, consiste en etiquetar cada una de las columnas y filas de la tabla. Por ejemplo, para un circuito de dos entradas, el siguiente podra ser el formato utilizado para el mapa de KARNAUGH. A A B 1 0 B 1 0

Tabla 9 Ejemplo de un Mapa de Karnaugh Cada cuadro se etiqueta de modo que los cuadros horizontales adyacentes difieran solo en una variable. Lo mismo debe suceder con los cuadro verticales adyacentes. En segundo lugar, se debe reflejar la tabla de verdad del circuito dado dentro del mapa. Esto se logra ubicando en el mapa las combinaciones que en la tabla posean una salida de 1. Entonces dentro de la matriz (mapa), en la interseccin de la fila y columna correspondiente se debe colocar un 1. El resto de cuadros se rellena con 0. Esto puede verse en el siguiente ejemplo con dos variables de entrada.

46

A 0 0 1 1

B 0 1 0 1

SALIDA 1 1 0 0

Tabla 10 Ejemplo de tabla de verdad B 1 0 B 1 0

A A

Tabla 11 Mapa de Karnaugh para el ejemplo de tabla de verdad Por ltimo se toman las etiquetas de los cuadros que contienen 1 y se operan por medio de OR (para obtener una suma de productos). En el ejemplo anterior, los cuadros que tienen el valor de 1 se etiquetan con AB y AB. Por lo tanto, la expresin que representa el circuito es: SALIDA = AB + AB Luego de haber obtenido la expresin del circuito, puede utilizarse una tcnica que reemplaza a la factorizacin matemtica denominada agrupamiento. El agrupamiento puede tomar dos celdas, cuatro, ocho, e incluso ms. El agrupamiento de un par de celdas adyacentes en un mapa de KARNAUGH elimina la variable que aparece en forma complementada y sin complementar. En el ejemplo mostrado, la variable que aparece complementada y natural es B. Por lo tanto la expresin es: SALIDA = A Los otros tipos de agrupamiento funcionan de forma similar.

1.4.4.3. Teoremas de Boole y Morgan

La siguiente tabla muestra los teoremas y postulados de Boole y de Morgan ms importantes que se utilizan para la simplificacin de circuitos. Aunque la demostracin de estos enunciados es sencilla e interesante, no se tratar en este documento. X+0=X X+X=1 X+X=X X+1=1 X1=X XX=0 XX=X X0=0 47

(X)=X X+Y=Y+X X+(Y+Z)=(X+Y)+Z X(Y+Z)=XY+XZ (X+Y)=XY X+XY=X

XY=YX X(YZ)=(XY)Z X+YZ=(X+Y)(X+Z) (XY)=X+Y X(X+Y)=X

Tabla 12 Teoremas de Boole y Morgan

1.4.5. Ejemplos

En esta seccin se pretende mostrar algunos ejemplos de circuitos lgicos combinatorios que son usados con frecuencia en la construccin de dispositivos complejos.

1.4.5.1. Sumadores

1.4.5.1.1. Sumador Medio

Un sumador medio es un circuito combinacional que realiza la suma de dos bits. Dicho circuito necesita dos entradas binarias (los bits a sumar) y dos salidas binarias (conocidas como suma y acarreo). La siguiente es la tabla de verdad que describe el comportamiento del circuito x 0 0 1 1 y 0 1 0 1 CARRY 0 0 0 1 SUMA 0 1 1 0

Tabla 13 Tabla de verdad del sumador medio La expresin simplificada en forma de productos correspondiente a este circuito es: SUMA = xy + xy = xy CARRY = xy

1.4.5.1.2. Sumador Total

El sumador total (completo) es el circuito combinacional capaz de sumar lgicamente tres bits de entrada. La siguiente tabla de verdad muestra el comportamiento de este circuito: 48

x 0 0 0 0 1 1 1 1

y 0 0 1 1 0 0 1 1

z 0 1 0 1 0 1 0 1

CARRY 0 0 0 1 0 1 1 1

SUMA 0 1 1 0 1 0 0 1

Tabla 14 Tabla de verdad del sumador total

Las expresiones que representan este circuito son: SUMA= xyz + xyz + xyz CARRY = xy + xz + yz La suma de dos nmeros binarios puede hacerse utilizando un conjunto de sumadores totales. Las dos primeras entradas (x, y) representan los bits que se sumarn. La tercera entrada (Z) puede corresponder al bit de acarreo de la posicin previa menos significativa. En la figura 18, se observa el esquema lgico de un sumador de tres bits usando Sumadores Totales. NUMERO A

Carry M SUMADOR TOTAL No. M Suma NUMERO B

Carry M-1

Carry 2 SUMADOR TOTAL No. 2 Suma 1

Carry 1

Carry 0 SUMADOR TOTAL No. 1

Suma 0

Figura 18 Esquema lgico de un sumador de tres bits usando Sumadores Totales.

49

1.4.5.2. Sustractores

1.4.5.2.1. Sustractor Medio

Es el circuito combinacional que resta dos bits y produce su diferencia. En cierta forma es similar diseo del sumador medio, ya que una salida corresponde a la diferencia entre los bits, y la otra, conocida por lo general como B (de Borrow) indica que se ha prestado un 1, ya que si el minuendo es menor que el sustraendo, la diferencia es 1 pero se lleva un 1 prestado. La tabla de verdad que describe al sustractor medio est dada por: X 0 0 1 1 y 0 1 0 0 B 0 1 0 1 D 0 1 1 0

Tabla 15 Tabla de verdad del sustractor medio La expresin de este circuito es: D = xy + xy B = xy Debe notarse que la salida D de este circuito es exactamente igual a la salida S del sumador medio.

1.4.5.2.2. Sustractor Completo

Es el circuito combinacional capaz de restar dos bits tomando en cuenta el resultado del bit menos significativo inmediatamente anterior. Dicho circuito necesita tres entradas y dos salidas. La tabla de verdad que lo describe es: X 0 0 0 0 1 1 1 1 y 0 0 1 1 0 0 1 1 z 0 1 0 1 0 1 0 1 B 0 1 1 1 0 0 0 1 D 0 1 1 0 1 0 0 1

Tabla 16 Tabla de verdad del sustractor completo 50

La expresin de un sumador completo est dada por: D = xyz + xyz + xyz+ xyz B = xy + xz +yz Debe notarse que la salida D de este circuito es igual a la salida S del sumador completo.

1.4.5.3. Relacin Entre Sumadores y Sustractores

Es posible convertir un sumador completo a un sustractor completo complementando la entrada x antes de su aplicacin a las compuertas que forman el bit de acarreo de salida. Otra forma de utilizar un sumador completo para que genere la diferencia de dos nmeros binarios consisten invertir todas las entradas del sustraendo y utilizar el primer acarreo Co con un valor de 1.

1.4.5.4. Generacin y Comprobacin de Paridad

El generador de paridad es bastante usado para el control de transmisiones. Para un generador de paridad impar, el bit de paridad P se modifica para que el numero total de bits transmitidos sea par (con P incluido). En el caso de paridad impar, el total de unos debe ser impar. La tabla de verdad de un generador de paridad impar se muestra a continuacin: x 0 0 0 0 1 1 1 1 y 0 0 1 1 0 0 1 1 z 0 1 0 1 0 1 0 1 PARIDAD IMPAR 1 0 0 1 0 1 1 0

Tabla 17 Tabla de verdad del generador de paridad impar La expresin de este circuito est dada por: P = x y ()z Donde () se conoce como operador de equivalencia. Su tabla de verdad es: 51

A 0 0 1 1

B 0 1 0 1

X = A()B 1 0 0 1

Tabla 18 Tabla de verdad del operador de equivalencia Cuando se recibe la transmisin, debe existir un circuito capaz de comprobar si la trama enviada es correcta (previamente, el receptor sabe que la paridad es par o impar). Para un circuito que comprueba la paridad impar, se tiene la siguiente tabla de verdad: x 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 y 0 0 0 0 1 1 1 1 0 0 0 0 1 1 1 1 z 0 0 1 1 0 0 1 1 0 0 1 1 0 0 1 1 P 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 COMPROBACION 1 0 0 1 0 1 1 0 0 1 1 0 1 0 0 1

Tabla 19 Tabla de verdad del circuito de comprobacin de paridad impar La expresin que describe este circuito es: C = x ()y()z()P

1.4.5.5. Decodificadores

Un decodificador es un circuito combinacional que convierte la informacin binaria de n lneas de entrada a un mximo de 2n lneas nicas de salida. Se denomina a un decodificador en lnea de n a m, aquel donde m (numero de salidas) sea menor o igual a 2n La siguiente tabla de verdad muestra un circuito decodificador de lnea de 2 a 4 52

x 0 0 1 1

y 0 1 0 1

D0 1 0 0 0

D1 0 1 0 0

D2 0 0 1 0

D3 0 0 0 1

Tabla 20 Tabla de verdad de un circuito decodificador de lnea de 2 a 4

1.5. LENGUAJE VHDL VHDL es un lenguaje de programacin diseado para describir el comportamiento de circuitos digitales.
1.5.1. Introduccin a VHDL

VHDL es la sigla que significa VHSIC Hardware Description Language. A su vez, VHSIC es el conjunto de iniciales de Very High Speed Integrated Circuits. Por lo tanto, VHDL significa Lenguaje de Descripcin de Hardware para circuitos integrados de alta velocidad.

1.5.1.1. Breve Resea Histrica

VHDL fue desarrollado a principios de los aos 80s, como un proyecto de investigacin del Departamento de Defensa de los Estados Unidos de Amrica. El desarrollo del lenguaje sigui su camino por varios aos, hasta que se present en el ao de 1985 una versin comercial (versin 7.2); con la ayuda de ingenieros de compaas como IBM, Texas Instruments e Intermetrics En 1986, la IEEE propuso la estandarizacin del lenguaje, lo que permiti en 1987 la creacin del lenguaje VHDL tal como se conoce hoy da. El resultado, el estndar IEEE 1076-1987. Sin embargo se han elaborado revisiones hasta el ao de 1994, pero el comportamiento bsico del lenguaje permanece intacto.

1.5.1.2. Caractersticas

Entre las principales caractersticas de VHDL encontramos las siguientes: Lenguaje de Simulacin. VHDL posee las herramientas necesarias para describir la funcionalidad de componentes electrnicos. En el se puede detallar el comportamiento de simples compuertas lgicas o complejos microprocesadores. VHDL permite el manejo de aspectos electrnicos, tales como la activacin y desactivacin de seales y los tiempos de demora entre las compuertas, entre otros. 53

Lenguaje de Diseo. Como cualquier lenguaje de alto nivel (Pascal, C o C++), VHDL posee un conjunto de sentencias y comandos tiles para el diseo estructurado de circuitos, y ofrece un conjunto de control y representacin de datos. A diferencia de los otros lenguajes de programacin, VHDL ha sido diseado para que una gran cantidad de procesos que ocurren concurrentemente puedan ser diseados. Lenguaje de Prueba. Una de las caractersticas ms sobresalientes de VHDL es su habilidad para capturar una especificacin de rendimiento para un circuito. Comnmente llamado Test Bench. Esta especificacin corresponde a las salidas esperadas de acuerdo a un conjunto de estmulos dados. VHDL es un lenguaje que permite el diseo en alto nivel de circuitos digitales. Pero tambin es usado para representar diseos en forma de bajo nivel, lo que permite la comunicacin con otras herramientas Puede reemplazar lenguajes Netlist como EDIF (un lenguaje Netlist, define una lista de componentes y conexiones digitales) Lenguaje Estndar EL uso de VHDL radica adems en que es un lenguaje adoptado por la comunidad electrnica. Cuando se usa un lenguaje estndar como VHDL se garantiza que los diseos son soportados por las herramientas de captura de diseo actuales y futuras. Adems, se puede hacer uso de una gran cantidad de libreras y cdigo que puede ser accesible desde bibliotecas o desde Internet.

1.5.1.3. Ventajas

VHDL puede ser usado para el diseo top-down (alto a bajo nivel), donde se puede definir la interfaz, los requerimientos y el Test Bench para cada componente. La captura del circuito es la fase en la que el detalle del sistema se define en la herramienta utilizada para el diseo. En esta fase, el usuario puede expresar el diseo (o partes de este) como diseo esquemtico (schematics), o por medio de descripciones VHDL. En la captura del diseo muchas veces se incluyen herramientas que complementan el lenguaje. Por ejemplo, el uso de representaciones grficas que reemplazan segmentos de cdigo. Si se desea simular la operacin del circuito para verificar que se cumplan los requerimientos funcionales y los retardos de tiempo adecuados, por medio un simulador, se puede aplicar el Test Bench, y comprobar los resultados obtenidos. La programacin estructurada de VHDL, permiten que este lenguaje sea una gran herramienta natural para la documentacin de circuitos complejos.

54

Un ejemplo claro de esta funcionalidad, radica precisamente en el Departamento de Defensa de los Estados Unidos de Amrica. Cualquier nuevo diseo electrnico debe documentarse en VHDL para permitir la fiel comunicacin entre los subcontratistas de esta entidad. El diseo esquemtico (Schematics) siempre ha tenido un gran uso en el diseo electrnico. Por esta razn, la herramientas de diseo VHDL poseen la capacidad de interactuar con diseos esquemticos para obtener diseos altamente eficientes e integrales. Existe un conjunto extenso de lenguajes para la programacin de dispositivos lgicos, que son lenguajes propietarios de cada uno de los fabricantes de circuitos. Entre los ms destacados encontramos: PALASM, ABEL, CUPL y AHDL de Altera. VHDL hace parte de los lenguajes universales HDL, como es el caso de Verilog.

1.5.1.4. Desventajas

La principal desventaja que posee VHDL es la visin popular de los nuevos diseadores que piensan que es un lenguaje demasiado extenso y complejo. Sin embargo, como se muestra en esta investigacin, conociendo unas pocas reglas sintcticas y algunos comandos, se pueden representar una gran cantidad de circuitos. Las herramientas de diseo para VHDL por lo general han tenido un costo ms alto que las otras que se encuentran en el mercado. Aunque en la actualidad, con el uso de circuitos lgicos reprogramables como FPGA, los vendedores ofrecen herramientas de bajo costo, que se integran a sistemas de sntesis, simulacin y programacin.
1.5.2. Mtodos de Diseo

Para describir el funcionamiento de un circuito digital, VHDL puede ser usado para disear de tres maneras distintas: Diseo Estructural Diseo de flujo de datos Diseo de Comportamiento Es importante aclarar que aunque estos tres mtodos son completamente diferenciables, en un diseo complejo pueden utilizarse todas las formas mencionadas, lo que permite una implementacin integral que cumpla las especificaciones requeridas del circuito.

1.5.2.1. Diseo Estructural

Al igual que un programa tradicional, el diseo puede ser ms entendible y eficiente si este se divide en un conjunto de bloques que cumplen una funcin especfica. Dichos bloques pueden interconectarse entre s formando un diseo completo. 55

Un diseo VHDL puede describirse como un bloque sencillo o como funcin de una gran cantidad de ellos. Cada bloque se denomina Entidad. Para que una entidad sea reconocida en el espacio global del diseo, debe poseer por si misma un conjunto de parmetros de interfaz (seales entrada / salida) y un conjunto de elementos que indiquen la funcionalidad del bloque. Una vez se tienen definidas las entidades bsicas, se pueden utilizar dentro de otras formando un diseo completamente estructurado. Cuando la entidad E necesita dentro de su diseo la entidad X, se dice que X es componente de la entidad E. Cuando la entidad E asigna seales para ser usadas en X (en la descripcin funcional del bloque), se usa el concepto de instancias de X. As X1 y X2 pueden ser instancias de X que son utilizadas dentro de la entidad recibiendo diferentes seales de entrada. El enfoque estructurado es el que se trabajar a lo largo del proyecto. En secciones posteriores se profundizar en este tema, utilizando comandos y sentencias propias del lenguaje VHDL.

1.5.2.2. Diseo por Flujo de Datos

Este diseo indica como las entradas y las salidas de componentes primitivos (ej. la compuerta and) estn interconectados. Es decir, describe la forma en que las seales fluyen a travs del circuito. Debe notarse que en un diseo estructural, el componente ms elemental, puede estar descrito por medio del flujo de seales. En el diseo por flujo de datos o seales, se utilizan comandos concurrentes.

1.5.2.3. Diseo de Comportamiento

El diseo por comportamiento difiere de los anteriores ya que no se necesita reflejar como es la implementacin del circuito. Unicamente se define su comportamiento. Este tipo de diseo se usa de 3 formas: En primer lugar, cuando se necesita modelar un elemento cuyo comportamiento es lo nico importante, en segundo lugar, cuando es demasiado tedioso el diseo por mtodos anteriores (interconexiones e implementacin) y por ltimo, el diseo por comportamiento es similar a la programacin de los lenguajes convencionales, lo que implica ventajas en el manejo de estructuras de datos y estructuras de control, como ciclos y condiciones.
1.5.3. Aproximacin al Diseo Estructural

En el proyecto que se realiza se utiliza el diseo estructural para implementar el diseo circuito deseado por el usuario. En esta seccin se explican los diversos conceptos que se involucran en el diseo estructural, as como la sintaxis y las palabras reservadas de VHDL necesarias para la representacin vlida de un circuito. 56

Como se menciona con anterioridad, el lenguaje VHDL es bastante complejo, y los comandos que se presentan en esta seccin son solo una pequea parte de este complejo y eficiente lenguaje. Dichos comandos son los que se utilizan en el proyecto realizado. NOTA: Se usarn en maysculas y en negrilla las palabras reservadas de VHDL. Este lenguaje no es sensitivo a minsculas o maysculas.

1.5.3.1. Definicin de Bloques

El concepto de programacin estructurada en los lenguajes convencionales es similar al que se plantea en el diseo estructural de VHDL. Un diseo complejo puede ser dividido en diversas unidades que son conectadas jerrquicamente. Cada una de esas unidades se denominan Bloques. Sin embargo, un diseo puede estar compuesto nicamente por un bloque en el que se describa todo el comportamiento del circuito. Para el trabajo con bloques, se necesitan definir entidades, arquitecturas, componentes e instancias.

1.5.3.2. Entidad

La interfaz de cada uno de los bloques se conoce como ENTIDAD. As, si el bloque que se est diseando es un circuito sumador simple, se necesitan dos entradas y dos seales de salida. Esto debe reflejarse dentro del grupo ENTIDAD. El siguiente es un ejemplo de la declaracin de una entidad simple en VHDL: ENTITY circuito_sumador IS PORT ( Entrada: IN STD_LOGIC_VECTOR (1 DOWNTO 0); Salida: OUT STD_LOGIC_VECTOR (1 DOWNTO 0) ); END circuito_sumador; La siguiente tabla describe los elementos bsicos de la declaracin de una entidad: ENTITY IS PORT Indican a VHDL el comienzo de la declaracin de la entidad circuito_sumador. Esta clusula define la interfaz del bloque, compuesta por una o ms seales que pueden ser entradas (IN), salidas (OUT) o bidireccionales (INOUT). Cada seal corresponde a un tipo de dato. (En el ejemplo es un vector denominado 57

END

STD_LOGIC_VECTOR) Define el fin de la declaracin de la entidad Tabla 21 Elementos bsicos de la declaracin de una entidad

1.5.3.3 Tipos De Seales

Como en cualquier lenguaje de programacin, en VHDL existen una gran cantidad de tipos de datos. El tipo ms elemental se denomina BIT, cuyos posibles valores son 0 1. Sin embargo, en el proyecto presentado en este informe se usan dos tipos de datos que no son propios del ncleo de VHDL, pero s hacen parte del estndar IEEE. STD_LOGIC STD_LOGIC_VECTOR Para que estos tipos sean reconocidos por VHDL, deben utlizarse dos comandos que permiten incluir una librera estndar IEEE, similar a include en lenguaje C: LIBRARY IEEE; USE IEEE.std_logic_1164.ALL; El comando LIBRARY instruye al compilador para que use el paquete denominado IEEE. Un paquete es un conjunto de libreras encapsuladas. USE indica el uso de la librera IEEE.std_logic_1164 y ALL permite que toda la librera sea compilada. 1. TIPO STD_LOGIC Este tipo de dato encapsula el comportamiento de un bit, con sus dos posibles valores 0 1. Adems, puede indicar un valor de Alta Impedancia, o Valor Sin Importancia. Los valores de este tipo de dato son: 'U' 'X' '0' '1' 'Z' 'W' 'L' 'H' '-' Sin inicializar Forzado Valor lgico 0. Valor lgico 1 Impedancia Alta Dbil desconocido Dbil 0 Dbil 1 Sin importancia

Tabla 22 Valores del tipo STD_LOGIC 58

2. TIPO STD_LOGIC_VECTOR Este tipo corresponde a una cadena de bits. La clusula: STD_LOGIC_VECTOR (1 DOWNTO 0); Define un vector STD_LOGIC de dos elementos: 0 y 1. La palabra DOWNTO simplemente indica el orden. Otra forma vlida de declarar el vector es: STD_LOGIC_VECTOR (0 TO 1); La primera expresin es la mas usada, ya que representa fielmente una cadena de bits, donde los valores ms significativos se corresponden a ndices mayores. Los tipos presentados anteriormente corresponden a seales que sirven de interfaces de entrada/salida, sin embargo, VHDL provee el comando SIGNAL que indica al compilador seales internas, que pueden usarse temporalmente dentro del diseo.

1.5.3.4. Arquitectura

El comportamiento de un bloque se describe en el grupo denominado Arquitectura. Para el ejemplo del sumador medio, la arquitectura puede describirse de la siguiente manera: ARQUITECTURE comportamiento OF circuito_sumador IS BEGIN Salida(1) <= Entrada(1) AND Entrada(0); Salida(0) <= Entrada(1) XOR Entrada(0); END comportamiento; La declaracin anterior indica a VHDL que la arquitectura comportamiento corresponde a la entidad circuito_sumador. En el proyecto que se presenta cada entidad tiene asociado un nica arquitectura (denominada COMPORTAMIENTO del bloque). En VHDL se pueden asignar diversas arquitecturas a una misma entidad. La siguiente tabla describe los elementos bsicos de la declaracin de una arquitectura: ARQUITECURE OF- IS Indica a VHDL el comienzo de la clusula del comportamiento de una entidad Palabra que seala el comienzo de la descripcin del BEGIN comportamiento. Entre ARQUITECTURE y BEGIN pueden implementarse otras clusulas que se vern en la siguiente seccin Operador de Asignacin <= Marca el fin de una sentencia ; Tabla 23 Elementos bsicos de la declaracin de una arquitectura 59

En el ejemplo anterior se pueden hallar varios temas importantes: Asignacin de seales. Se realizan por medio del operador <=, y equivale a la asignacin de los lenguajes convencionales La diferencia radica en que este operador indica ante todo una transferencia de seales ms que de valores. En VHDL existe el concepto de Variable y Constante, donde la asignacin se realiza por medio del operador : =. Acceso a elementos de un vector. Para acceder a un elemento de un vector de bits STD_LOGIC_VECTOR se usa el operador (). Similar al operador [] en las matrices del lenguaje C. Operadores. Dentro de la arquitectura de un bloque (en un diseo concurrente),se pueden utilizar como en cualquier lenguaje de programacin operadores lgicos, operadores relacionales, operadores aritmticos, operadores para el manejo de bits. As mismo existen clusulas condicionales. Existen sentencias para el uso de ciclos, pero se debe hacer dentro de una clusula PROCESS que define un diseo secuencial. En el trabajo que se presenta, se utilizan ante todo operadores lgicos y una sentencia condicional conocida como WITH-SELECT

1.5.3.4.1. Operadores Lgicos

Los siguientes son los operadores lgicos que se pueden utilizar en VHDL: 1. 2. 3. 4. 5. 6. 7. AND OR NOT XOR NAND NOR XNOR

En el captulo Circuitos Lgicos Combinatorios se detallan la mayora de estas funciones.

1.5.3.4.2. Sentencia With-Select

La estructura de WITH-SELECT se describe a continuacin: WITH Entrada SELECT Salida <= Valor_Salida0 WHEN Valor_Entrada0, 60

Valor_Salida1 WHEN Valor_Entrada1, Valor_Salida2 WHEN Valor_Entrada2, ... Valor_SalidaN WHEN OTHERS; Esta sentencia permite asignar un valor a la seal Salida diferente para un conjunto (o subconjunto) de valores de la seal Entrada. Se asemeja al comando SWITCH-CASE del lenguaje C (A decir verdad, dentro de la clusula PROCESS, puede usarse una sentencia CASE que tiene una funcin similar a WITH-SELECT).

1.5.3.5. Componentes e Instancias

Los ejemplos presentados en las secciones anteriores, describen completamente un bloque denominado circuito_sumador. A continuacin se muestra el cdigo total: LIBRARY IEEE; USE IEEE.std_logic_1164.ALL; ENTITY circuito_sumador IS PORT ( Entrada: IN STD_LOGIC_VECTOR (1 DOWNTO 0); Salida: OUT STD_LOGIC_VECTOR (1 DOWNTO 0) ); END circuito_sumador; ARQUITECTURE comportamiento OF circuito_sumador IS BEGIN Salida(1) <= Entrada(1) AND Entrada(0); Salida(0) <= Entrada(1) XOR Entrada(0); END comportamiento; La siguiente tabla de verdad describe como se comporta el circuito circuito_sumador: Entrada 0 Entrada 1 0 0 0 1 1 0 1 1 Salida 1 0 0 0 1 Salida 0 0 1 1 0

Tabla 24 Comportamiento del circuito circuito_sumador Ahora supngase que se tiene otro bloque denominado mi_and, que simplemente recibe como seales de entrada dos bits, y retorna la operacin AND en una seal de salida. El cdigo que 61

describe este bloque utilizando los comandos que se han detallado anteriormente puede ser el siguiente: LIBRARY IEEE; USE IEEE.std_logic_1164.ALL; ENTITY mi_and IS PORT ( Entrada_mi_and: IN Salida_mi_and: OUT ); END mi_and;

STD_LOGIC_VECTOR (1 DOWNTO 0); STD_LOGIC

ARQUITECTURE comportamiento_mi_and OF mi_and IS BEGIN Salida_mi_and <= Entrada_mi_and (1) AND Entrada_mi_and (0); END comportamiento_mi_and; Con este bloque, en circuito_sumador es posible reemplazar la llamada a la funcin predefinida AND de VHDL y utilizar mi_and. Para conectar bloques, VHDL permite el uso de componentes e instancias. La clusula COMPONENT (componente) es usada para definir la interfaz con el bloque que ser utilizado, lo que se denomina en trminos de diseo, el bloque de nivel inferior (down level). As, dentro de la definicin del comportamiento (ARQUITECTURE) de circuito_sumador se puede usar la clusula COMPONENT: ARQUITECTURE comportamiento OF circuito_sumador IS COMPONENT mi_and PORT ( Entrada_mi_and: IN STD_LOGIC_VECTOR (1 DOWNTO 0); Salida_mi_and: OUT STD_LOGIC ); BEGIN ... ... ... END comportamiento; La interfaz definida dentro de la clusula COMPONENT de comportamiento corresponde a la misma definida en la sentencia ENTITY del bloque ( mi_and). Se define una instancia, como la copia de un componente que va ha ser utilizado dentro de una arquitectura. La instancia del componente mi_and dentro de circuito puede implementarse as: 62

BEGIN instancia_1_mi_and: mi_and PORT MAP (Entrada,Salida(1)); Salida(0) <= Entrada(1) XOR Entrada(0); END comportamiento; En las lneas anteriores se puede observar: 1. La instancia del componente mi_and se denomina instancia_1_mi_and 2. La entidad del componente se llama mi_and. 3. La clusula PORT MAP especifica como es la relacin de las seales del bloque que se implementa (top level) con el componente que se conecta (down level). De esta manera, el vector Entrada de circuito se conectar con el vector Entrada_mi_and de mi_and, y el elemento 1 del vector de Salida de circuito se conectar con el bit Salida_mi_and de mi_and. Un mismo componente puede tener varias instancias que se conectan de formas distintas al diseo. Debe comentarse que aunque parece inoficioso utilizar todo un bloque lgico para realizar una operacin sencilla como la compuerta AND (que hace parte de los operadores lgicos predefinidos del ncleo de VHDL) , la explicacin anterior puede extenderse a bloques ms complejos que pueden verse como cajas negras en el momento del diseo. De esta forma. el diseo circuito completo es el siguiente: LIBRARY IEEE; USE IEEE.std_logic_1164.ALL; ENTITY mi_and IS PORT ( Entrada_mi_and: IN Salida_mi_and: OUT ); END mi_and;

STD_LOGIC_VECTOR (1 DOWNTO 0); STD_LOGIC

ARQUITECTURE comportamiento_mi_and OF mi_and IS BEGIN Salida_mi_and <= Entrada_mi_and (1) AND Entrada_mi_and (0); END comportamiento_mi_and; LIBRARY IEEE; USE IEEE.std_logic_1164.ALL; ENTITY circuito_sumador IS PORT ( Entrada: IN STD_LOGIC_VECTOR (1 DOWNTO 0); 63

Salida: OUT STD_LOGIC_VECTOR (1 DOWNTO 0) ); END circuito_sumador; ARQUITECTURE comportamiento OF circuito_sumador IS COMPONENT mi_and PORT ( Entrada_mi_and: IN STD_LOGIC_VECTOR (1 DOWNTO 0); Salida_mi_and: OUT STD_LOGIC ); BEGIN instancia_1_mi_and: mi_and PORT MAP (Entrada,Salida(1)); Salida(0) <= Entrada(1) XOR Entrada(0); END comportamiento;

1.6. FIELD PROGRAMMABLE GATE ARRAY: FPGA

1.6.1. Conceptos Bsicos

Un dispositivo lgico programable es un dispositivo en el cual la descripcin lgica de un circuito puede ser modificada o almacenada a travs de programacin.

Figura 19 Estructura de un CPLD. El dispositivo ms comn se denomina PAL (Programmable Array Logic). Un dispositivo PAL consiste simplemente de un arreglo de compuertas AND y otro de compuertas OR. El primer arreglo puede ser programado, el segundo, es fijo. Una matriz de selectores indica qu entradas del circuito PAL deben ser conectas a las entradas de las compuertas AND, las cuales se interconectan por medio de la matriz de compuertas OR. As mismo, las salidas pueden ser retroalimentadas dentro del dispositivo. 64

Un dispositivo CPLD (Complex Programmable logic devices, Figura 19) es un dispositivo de pequeas celdas lgicas (bloques funcionales BF-), las cuales pueden ser interconectadas entre s de acuerdo al programa establecido para el circuito. Una gran cantidad de compaas fabrica CPLDs, como es el caso de: AMD, Lattice, XILINX, y Cypress Un FPGA (Field Programmable Gate Array, Figura 20) es un arreglo de bloques lgicos que pueden ser encadenados para formar una implementacin lgica de un circuito complejo. Existen dos tipos de FPGAs Grano Fino Aquel que se encuentra elaborado por una gran cantidad de compuertas, transistores o pequeas celdas lgicas. Grano Grueso Consta de celdas lgicas complejas, que a su vez son hechas de un conjunto de flip-flops y Tablas de Bsqueda (Look up Tables LUT-), las cuales pueden generar funciones lgicas combinatorias. Dentro de cada uno de estos bloques, existen multiplexores que permiten dar diferentes usos a esta macrocelda. As mismo, cada macrocelda se conecta con otras gracias a una matriz selectora que es implementada con multiplexores, fusibles /antifusibles, o transistores. Por esto, se pueden diferenciar distintos tipos de FPGAs: Basada en PROM/EPROM/EEPROM/FLASH Aquellas que son programadas fuera del circuito y no pueden ser reprogramadas Basada en Antifusibles/Fusibles Como las basadas en PROMS solo pueden ser programadas una sola vez. Su ventaja radica en su tamao y su bajo costo. Basada en Static Ram Las celdas SRAM son implementadas como funciones generadoras para simular la lgica combinatoria, y adems controlan los multiplexores y los recursos de enrutamiento. Actualmente son las ms populares.
1.6.2. FPGA Serie XC4000

Actualmente se cuenta en la Universidad Nacional de Colombia (sede Bogot) con un dispositivo lgico reprogramable FPGA del tipo XC4000. Sobre este dispositivo se realiza la simulacin del circuito sumador. La presente seccin pretende describir las caractersticas principales de este elemento. Este dispositivo es fabricado por la empresa Xilinx Inc. Los datos presentados a continuacin (figuras, esquemas y especificaciones tcnicas) fueron suministrados por dicha compaa.

65

1.6.2.1. Descripcin

Un dispositivo de la serie XC4000, consta de un conjunto de Bloques Lgicos Configurables (Configurable Logic Block CLB-), interconectados de diversas maneras dentro de un permetro definido por Bloques de Entrada/Salida programables (Input/Output Block IOB-). Los dispositivos se programan leyendo la configuracin proveniente de un archivo de datos y registrndola en celdas de memoria. Estos dispositivos son reprogramables, lo que implica que pueden ser usados para la implementacin de diseos donde el hardware es cambiado de forma dinmica, o donde se debe adaptar a distintas condiciones del ambiente. As, se pueden implementar sistemas que sean capaces de auto-diagnosticarse, o bien, de reconfigurarse para una nueva especificacin.

Figura 20 Estructura de un FPGA.

1.6.2.2. Componentes Bsicos

Los siguientes son los elementos bsicos de un dispositivo FPGA de la familia XC4000.

1.6.2.2.1 Bloques Lgicos Configurables

La mayor parte de la lgica que puede ser implementada en un FPGA, se hace dentro de los Bloques Lgicos Configurables (CLB, Figura 21). Cada CLB esta formado por dos generadores de funciones de 4 entradas (denominadas F y G). Dichas funciones generadoras tienen la capacidad de implementar cualquier funcin booleana de 4 entradas. Se implementan por medio de tablas de bsqueda. Una gran cantidad de funciones lgicas combinatorias necesitan 4 o menos entradas. Sin embargo, dentro de un CLB se encuentra un tercer generador de funciones, conocido como H. Este elemento tiene 3 entradas. 66

Figura 21 Estructura de un Bloque Lgico.

Un CLB puede ser usado para implementar cualquiera de las siguientes funciones: Cualquier funcin de hasta 4 variables, mas una segunda funcin de 4 variables no relacionadas, y cualquier funcin de 3 variables no relacionadas. Cualquier funcin de 5 variables. Cualquier funcin de 4 variables con algunas funciones de seis variables. Algunas funciones de hasta 9 variables. Un Bloque Lgico Configurable consta adems de los siguientes elementos: Flip-Flops: Permiten el paso de seales dentro del bloque, as como almacenan los resultados combinacionales. Se disparan por medio de una entrada de reloj comn. Seales de Control. Multiplexores.

1.6.2.2.2. Bloques de Entrada/Salida

Los bloques de entrada/salida (IOB, Figura 22) determinan la interfaz entre la lgica interna implementada y el ambiente externo. Cada IOB controla un pin de la tarjeta y puede ser configurado para seales de entrada, salida o bidireccionales.

67

Figura 22 Estructura de un Bloque E-S.

1.6.2.2.3. Buffers de Tres Estados

Una pareja de buffers de tres estados se asocia a cada CLB en la matriz de interconexiones. Dichos elementos pueden ser usados para dirigir las seales hacia las lneas de conexin que se encuentran rodeando al CLB. Pueden ser usados adems para la programacin de buses.

1.6.2.2.4. Interconexiones

Todas las conexiones internas se componen de segmentos metlicos con cruces y matrices programables que permiten disear diferentes rutas. Existen tres tipos de interconexin que son: Enrutamiento del CLB asociado con cada fila y columna del arreglo de CLBs. Enrutamiento del IOB alrededor de la matriz de CLBs. Conexin de los recursos Entrada/Salida con los bloques de lgica interna. Enrutamiento global que consta de redes dedicadas a la distribucin de pulsos de reloj a travs del dispositivo con un mnimo de demora.

1.6.2.3. Reconfiguracin del FPGA

Existen dos tipos de reconfiguracin en estos dispositivos: Esttica y Dinmica. Figura de fotocopia.

68

1.6.2.3.1. Reconfiguracin Esttica

Es la que se lleva a cabo en tiempo de compilacin. El dispositivo lee un paquete de datos de programa mientras el sistema no se encuentra actualmente operando. Ya que el tiempo de reconfiguracin puede ser ignorado, la reconfiguracin de un circuito es simple.

1.6.2.3.2. Reconfiguracin Dinmica

En este tipo de reconfiguracin, el dispositivo puede modificar el contenido lgico sin perturbar la operacin del sistema. En un dispositivo FPGA de la familia XC4000 se debe reconfigurar todo el circuito, mientras que en series ms complejas, como el caso de XC6200, se pueden modificar solo algunas partes del diseo.

1.6.2.4. Programacin del FPGA

La reconfiguracin del FPGA se hace bsicamente por medio de la lectura de un paquete de datos que indica las caractersticas que el dispositivo debe tener. Para llegar a esta configuracin se deben seguir los siguientes pasos bsicos: 1. 2. 3. 4. Captura del Diseo. Implementacin del Diseo. Verificacin Configuracin.

1.6.2.4.1. Captura del Diseo

La descripcin del circuito que debe ser implementado en el FPGA puede realizarse por medio de herramientas CAD, donde se realizan diseos esquemticos. Adems existen niveles de alto nivel para la descripcin de Hardware (Hardware Description Language HDL-) que pueden combinarse con el diseo esquemtico. La mayora de herramientas CAD poseen interfaces con distintos vendedores, entre ellos Xilinx. En la siguiente figura se encuentra el diseo de un cronmetro digital que se implementa en un circuito Xilinx.

69

Figura 23 Captura del diseo en FOUNDATION de XILINX.

1.6.2.4.2. Implementacin del Diseo

Despus de la captura del diseo para un circuito FPGA de la familia Xilinx, se convierte a un formato XNF (Xilinx Netlist Format) o a un formato estndar EDIF. La figura 24 es el cdigo XNF de un diseo capturado en FOUNDATION SERIES de Xilinx. El software de Xilinx se encarga de particionar el diseo en bloques, luego analiza el lugar correspondiente de cada bloque para obtener un rendimiento ptimo, y por ltimo selecciona las rutinas de interconexin. Este proceso ocurre automticamente, pero el usuario puede modificarlo especificando puntos crticos a tener en cuenta. Una vez el proceso termina, se produce un reporte de tiempo para el dispositivo y se genera un archivo denominado Bitstream, que es cargado en la FPGA. Estos datos son los encargados de controlar o definir los circuitos combinatorios, los flip-flops, la estructura de interconexin, los resistores y los buffers de entrada/salida.

70

LCANET, 6 PROG, Synopsys, FPGA Express, v2.1, Build 2.1.2.23.7.1998 PART, 4003EPC84-1 SYM, c23_c0, AND, LIBVER=2.0.0 PIN, I0, I, c23_n0, , , INV PIN, I1, I, c23_n1, , , INV PIN, O, O, Salida_MI_PARA_SUMA_COMPLETO_1, , , INV END SYM, c23_c1, AND, LIBVER=2.0.0 PIN, I0, I, Entrada_MI_PARA_SUMA_COMPLETO_1<1>, , , INV PIN, I1, I, Entrada_MI_PARA_SUMA_COMPLETO_1<0>, , PIN, O, O, c23_n0, , END SYM, c23_c2, AND, LIBVER=2.0.0 PIN, I0, I, Entrada_MI_PARA_SUMA_COMPLETO_1<1>, , PIN, I1, I, Entrada_MI_PARA_SUMA_COMPLETO_1<0>, , , INV PIN, O, O, c23_n1, , END SYM, FMAP_0, FMAP, LIBVER=2.0.0 PIN, I1, I, Entrada_MI_PARA_SUMA_COMPLETO_1<1>, , PIN, I2, I, Entrada_MI_PARA_SUMA_COMPLETO_1<0>, , PIN, O, I, Salida_MI_PARA_SUMA_COMPLETO_1, , END SIG, Entrada_MI_PARA_SUMA_COMPLETO_1<1>, PIN=Entrada_MI_PARA_SUMA_COMPLETO_1<1> SIG, Entrada_MI_PARA_SUMA_COMPLETO_1<0>, PIN=Entrada_MI_PARA_SUMA_COMPLETO_1<0> SIG, Salida_MI_PARA_SUMA_COMPLETO_1, PIN=Salida_MI_PARA_SUMA_COMPLETO_1 EOF

Figura 24 cdigo XNF de un diseo capturado en FOUNDATION SERIES de Xilinx.

1.6.2.4.3. Verificacin del Diseo

La verificacin del diseo se logra por medio de la creacin de seales estmulo al circuito implementado. La gran mayora de herramientas proveen funciones para la verificacin y simulacin de circuitos de forma funcional y por tiempos.

1.6.2.4.4. Configuracin

La configuracin es el proceso por el cual el diseo del circuito (archivo bitstream) se carga en el dispositivo lgico reprogramable. El software utilizado para la carga del FPGA permite al usuario modificar el tipo de configuracin que se llevar a cabo. Puede configurarse de dos formas dependiendo del tamao de los datos: Configuracin Serial (Bits): Usa una PROM serial. Configuracin Paralela (Bytes): Por medio de PROM estndar o un multiprocesador.

71

2. ANALISIS Y DISEO DEL PROBLEMA

2.1. METODOLOGIA La metodologa que se aplico para las fases de anlisis y diseo del problema, combina la ingeniera de software tradicional[4] con el ciclo de vida propuesto en el documento de G. Maana[5] (Ver Anexos).

2.2. ANALISIS DEL PROBLEMA PARA EL DESARROLLO DEL MODELO

2.2.1. Anlisis Preliminar

Dentro de este proceso se requiere una descomposicin funcional del sistema analizando los procesos que componen la aplicacin, en este caso el sistema general abarca desde la entrada de datos requeridos por el algoritmo de programacin gentica, el cual da como resultado un programa generado tipo LISP que es capaz de resolver un problema (encontrar la estructura de un circuito lgico combinatorio).
2.2.2. Especificacin de Requerimientos

Un simulador de Programacin gentica para el diseo de circuitos combinatorios, es una aplicacin grfica interactiva, en la cual el usuario especifica una tabla de verdad para un circuito de n entradas y m salidas, que debe ser construido por medio de la programacin gentica, definiendo un conjunto de parmetros como son: probabilidad de cruce, mutacin, seales de entrada, seales constantes, funcin de usuario, funcin bsica, nmero de generaciones, tipo de seleccin, tipo de aptitud, y nmero de niveles de la poblacin inicial. Adems de sta informacin, el usuario puede seleccionar las funciones a utilizar en la ejecucin del algoritmo, ya sean propias (AND, OR, NOT, XOR) o creadas por l mismo (con el mismo formato del circuito buscado, excepto que toda funcin debe cumplir con el requisito de tener solamente una salida). El usuario tiene como herramientas mens con todas las funciones y botones rpidos para las ms usadas. Los procedimientos que seguir el usuario son los siguientes: Leer el archivo de tabla de verdad del circuito buscado. Ingresar por teclado, los parmetros de configuracin del algoritmo gentico. Seleccionar funciones creadas por el mismo. Ejecutar el algoritmo de programacin gentica. 72

Salvar el resultado del algoritmo, como un archivo de VHDL, una sentencia tipo LISP, adems de las estadsticas de ejecucin del algoritmo. Restricciones: El simulador no tendr mltiple documento, ser SDI. Solo operar bajo entorno Windows. El siguiente diagrama (Figura 25) de E/S muestra el comportamiento bsico esperado de la aplicacin:
Datos propios circuito buscado del Algoritmo de Programacin Gentica Programa con sintaxis LISP que resuelve el Circuito buscado Representacin Grfica y VHDL de la Solucin.

Datos propios para problemas de Programacin Gentica

Figura 25 Diagrama de Flujo de datos de la Aplicacin.

2.2.2.1 Entradas

El programa permite al usuario proporcionar los valores de ejecucin tpicas del algoritmo como son: las probabilidades de cruce y mutacin, el tamao de la poblacin, el nmero de individuos por generacin, tipo de seleccin, probabilidad de funciones o terminales y constantes, esto con el fin de que sea flexible y permita observar el comportamiento del algoritmo segn la variacin de dichos parmetros. Adems, el usuario debe ingresar la tabla de verdad del circuito que desea buscar, con el nmero de salidas y entradas del mismo. El usuario puede almacenar los parmetros utilizados en forma de proyecto, con lo cual puede utilizar la configuracin establecida para pruebas posteriores.

2.2.2.2. Algoritmo de Programacin Gentica

La ejecucin del algoritmo de programacin gentica propiamente dicho tiene como base todas las operaciones genticas descritas anteriormente (seleccin, cruce y mutacin). La funcin objetivo empleada se encarga de la ejecucin del rbol, con los datos de entrada de las 2n combinaciones posibles de entradas, para luego comparar el resultado de la ejecucin con las salidas correspondientes esperadas para la combinacin de entradas dada. De sta manera se calcula la aptitud ajustada, relacionada con la mayor cantidad de salidas acertadas, por ejemplo para un circuito de 3 entradas y 2 salidas, las combinaciones posibles de la tabla de verdad son 73

23=8, por tanto la aptitud mxima de un individuo ser de la cantidad de combinaciones por el nmero de salidas, 8x2=16. La estructura de datos bsica para el almacenamiento de los programas generados es de rbol binario de profundidad inicial mxima constante, y durante el proceso, se trabaja con una profundidad mxima esto con el fin de mantener el control de la memoria y permitir que los rboles generados mantengan en lo posible el comportamiento esperado. Los criterios de parada para el algoritmo son: - El nmero de generaciones que el usuario haya definido. - Cuando el algoritmo deje de evolucionar lo suficiente, es decir que la aptitud del mejor individuo en cada generacin no se modifique demasiado. - El mejor individuo es hallado antes de cumplir el nmero de generaciones establecido inicialmente

2.2.2.3. Salidas

Se tienen como salidas: 1. La traduccin del rbol generado en trminos de llamadas a las funciones propias del problema implementadas en LISP. 2. La traduccin del rbol en lenguaje VHDL, con el fin de permitir la implementacin fsica del circuito. 3. Archivos de estadsticas.

2.3. DISEO DE LA APLICACION.

2.3.1. Descomposicin Funcional

Siguiendo el modelo de anlisis del problema se plantea el siguiente diagrama bsico de representacin funcional (Figura 26): 1 2

1. Ingreso de datos por teclado

2. Construccin y Ejecucin del Algoritmo de Programacin Gentica.

3. Presentacin de la solucin al circuito buscado.

Figura 26 Diagrama de Representacin Funcional de la Aplicacin. 1. Ingreso de datos por teclado Responsable: Usuario Descripcin: Los datos que requiere el programa para funcionar son proporcionados por el usuario, estos se refieren principalmente a: Parmetros propios del algoritmo como la probabilidad de cruce y mutacin, el nmero de 74

individuos, el tamao de la poblacin, el nmero de generaciones y el tamao mximo de los rboles, etc. 2. Construccin y ejecucin del algoritmo de programacin gentica Responsable: Algoritmo de programacin gentica. Descripcin: Dado que se adopta la visin propuesta por Koza segn la cual, la representacin ms conveniente para la programacin gentica es la de rboles[3]. La construccin de la poblacin de rboles implica el llenado de los mismos con las funciones y terminales correspondientes al dominio del problema cuidando que la sintaxis sea correcta y que el tamao de los rbol no sobrepase los lmites establecidos por el usuario. Adems se encarga de la ejecucin del algoritmo gentico con los parmetros establecidos por el usuario. 3. Presentacin de la solucin del circuito buscado. Responsable: Interfaz de usuario. Descripcin: Una vez haya sido evaluado e interpretado el mejor rbol de la poblacin, la interfaz se encarga de presentar la solucin al usuario en forma de cdigo LISP y de lenguaje VHDL.
2.3.2. Flujo de Datos

Los puntos de flujo de informacin dentro de la aplicacin estn representados en la Figura 20, como las flechas de unin de los bloques de la descomposicin funcional, y son: 1. Datos relevantes proporcionados por el usuario son transmitidos al modulo de construccin y ejecucin del algoritmo de programacin gentica, de modo que la poblacin inicial pueda ser creada para dar comienzo a la ejecucin del algoritmo. 2. El rbol marcado como mejor individuo de la poblacin, luego de la ejecucin del algoritmo de programacin gentica con los parmetros iniciales dados por el usuario es transferido a la interfaz de usuario con el propsito de presentar la solucin a ste de manera comprensible. Del anlisis anterior se puede llegar a la definicin de los mdulos principales de la aplicacin y el flujo de datos entre ellos (Figura 27).

75

Algoritmo de Programacin Gentica Interfaz Con el Usuario

Parmetros de Ejecucin

3. Manipulador de las estructuras de datos en rbol

Manipulacin de la Estructura de los Arboles

1. Entrada de Datos

2. Presentacin resultados

de

4. Ejecucin del Algoritmo de Programacin Gentica

Evaluacin de la Aptitud de los rboles

Programa Resultado

5. Intrprete de Resultados

Figura 27 Descomposicin por mdulos de la aplicacin.

2.3.3. Definicin de la Estructura LISP (Arboles) y Consideraciones Iniciales del Problema

Como se observo en el capitulo referente a la programacin gentica, todos los individuos deben tener una estructura sintcticamente correcta, es por esto que para facilidad de ejecucin y funcionamiento, se aplicar al rbol una sintaxis similar a la utilizada en LISP, con las siguientes caractersticas:

2.3.3.1. La Raz

Para la raz del rbol, se ha definido la funcin CONCAT, la cual retorna una cadena de bits, que representa la salida de cada rama hijo de la funcin, por ejemplo, si el circuito buscado tiene 3 (tres) salidas, as ser la cantidad de hijos de la funcin CONCAT, y ella retornara al ejecutar el rbol con un conjunto de entradas determinadas una cadena de 3 bits, es denotar que esta funcin solo ser usada en la raz del rbol. Esta funcin se crea para uso interno del programa.

2.3.3.2. Las Funciones

Inicialmente se encuentran definidas las funciones booleanas de dos entradas: AND, OR y XOR, y la funcin de una entrada NOT. Ninguna de ellas estar en la raz del rbol. El usuario podr definir otras funciones, con la restriccin de que estas solamente tendrn un bit de salida, y un nmero variable de entradas limitado. 76

2.3.3.3. Las Terminales

Corresponden al nmero de entradas definidas inicialmente para el circuito buscado, y se corresponden con las letras del alfabeto, desde la A hasta la Z. Adems, se permite el uso de las seales constantes 1 y 0.
2.3.3.4. Ejemplo

El rbol representado en la figura 28, es segn la descripcin hecha anteriormente, un circuito sumador completo de 2 bits, con entradas A, B y salidas S (Suma) y C (Carry), la representacin del circuito en diagrama lgico se puede ver en la misma figura.

Figura 28 Representacin lgica y de rbol de un circuito sumador completo de 2 bits, cuya representacin LISP corresponde a: CONCAT((XOR(A B))(AND(A B)))

2.3.4. Clases
2.3.4.1. Lista Preliminar de Clases

En primer lugar, se deben encontrar las clases del sistema, para ello se comenzar sealando las frases nominales de la Especificacin de Requerimientos, obteniendo una lista preliminar, en ella aparecern frases con clases obvias, frases sin sentido alguno para nuestro objetivo y frases sobre las cuales no se puede estar seguro. Se tiene entonces: Un simulador de Programacin gentica para el diseo de circuitos combinatorios, es una aplicacin grfica interactiva, en la cual el usuario especifica una tabla de verdad para un circuito combinatorio de n entradas y m salidas, que debe ser construido por medio de la programacin gentica, definiendo un conjunto de parmetros como son: probabilidad de cruce, mutacin, seales de entrada, seales constantes, funcin de usuario, funcin bsica, nmero de generaciones, tipo de seleccin, tipo de aptitud, y nmero de niveles de la poblacin inicial. Adems de sta informacin, el usuario puede seleccionar las funciones a utilizar en la ejecucin del algoritmo, ya sean propias (AND, OR, NOT, XOR) o creadas por l mismo (con el mismo 77

formato del circuito buscado, excepto que toda funcin debe cumplir con el requisito de tener solamente una salida). El usuario tiene como herramientas mens con todas las funciones y botones rpidos para las ms usadas. Los procedimientos que seguir el usuario son los siguientes: Leer el archivo de tabla de verdad del circuito buscado. Ingresar por teclado, los parmetros de configuracin del algoritmo gentico. Seleccionar funciones creadas por el mismo (tambin manejadas por archivo, herramienta de creacin de tablas). Ejecutar el algoritmo de programacin gentica. Salvar el resultado del algoritmo, como un archivo de VHDL, una sentencia tipo LISP, adems de las estadsticas de ejecucin del algoritmo. Reiniciar el proceso con los individuos resultantes al terminar el proceso. Con esta primera inspeccin llegamos a la siguiente lista de posibles clases: Simulador de Programacin Gentica Aplicacin grfica interactiva Circuitos combinatorios Tabla de verdad Entradas Salidas Parmetros Algoritmo gentico Terminales(Entradas o Constantes) Funciones definidas por el usuario Mens Herramienta de creacin de tablas Botones Archivo de VHDL Sentencia tipo LISP Individuos Aplicacin Aplicacin Clase primaria. Manipula las tablas de circuitos y funciones (Manejador de Archivos) Atributo Atributo Atributo Instancia del objeto GASteadyState de la librera GALib(Ver anexos). De seales usadas por el circuito. Caractersticas y orden Modelado por Windows Aplicacin auxiliar Modelado por Windows Mtodo Mtodo Instancias de los objetos GATreeGenome agrupados en la instancia de GAPopulation de la librera GALib(Ver anexos). Atributo

Estadsticas

Tabla 25 Lista preliminar de clases Con esta lista preliminar podemos obtener una nueva lista de clases en la cual son excluidos los atributos y los eventos ya modelados.

78

2.3.4.2. Lista Final de Clases

De la tabla anterior, tenemos entonces la siguiente lista de clases : TControles: Objeto encargado de la interfaz de la aplicacin. Sennal: Encargado de la representacin de una seal, constante (1 0)o de entrada al circuito [A...Z]. TNodo: Representa un nodo de un individuo(rbol) funcin o terminal. TCircuito: interfaz del algoritmo gentico con la aplicacin principal. TEvalua: Se encarga de evaluar, recorrer y generar el cdigo VHDL o LISP de cualquier rbol sintcticamente correcto. Funcin_usuario: Representacin de una funcin definida por el usuario. Patron: Representa una tabla de verdad, ya sea de una funcin definida por el usuario o la de un circuito buscado. THilo: Thread que manipula la ejecucin del algoritmo gentico permitiendo al usuario mantener el control de la aplicacin. TVariables: Generador de variables para el cdigo VHDL. TFormaArbol: Manipula el conjunto de las funciones activas tanto bsicas como de usuario.

2.3.4.3. Registro De Clases

En las tarjetas presentadas a continuacin se registran las clases con los siguientes datos: Nombre. Tipo de clase: Concreta (C ) o Abstracta (A), segn el fin con el cual fueron creadas, es decir, si se crean para agrupar atributos y comportamientos comunes a un conjunto de subclases, sern Abstractas; pero si tienen el fin de crear objetos a partir de ellas y definir los mtodos especificados en una clase abstracta, sern entonces Concretas. Superclase: clase de la cual hereda. Subclase: clase de las cual es padre. Responsabilidades: conocimiento que la clase debe mantener y acciones que debe realizar. Colaboraciones: clases que le ayudan a cumplir sus responsabilidades en caso de no poderlas realizar por s sola. Al respaldo de la tarjeta se presenta el propsito de la clase dentro de la aplicacin.

79

Clase: TControles Responsabilidades

Superclase:

Subclase: Colaboraciones

Editar los objetos que intervienen en la simulacin. Mostrar la simulacin. Controlar los parmetros de ejecucin. Mostrar los resultados de la simulacin.

TCircuito: Se encarga de inicializar las estructuras necesarias para la ejecucin del algoritmo gentico. Funcion_Usuario: Brinda el comportamiento de una funcin de usuario para que l pueda modificar el conjunto existente. THilo: Toma una referencia de TCircuito y crea la ejecucin de un Algoritmo gentico en un proceso independiente. TFormaArbol: Guarda la lista de funciones bsicas y de usuario activas.

Clase: TControles Propsito

Recibe los parmetros necesarios para la resolucin del problema, y controla la ejecucin del programa, para luego presentar en pantalla los resultados del mismo.

Clase: TFormaArbol Responsabilidades

Superclase:

Subclase: Colaboraciones

Mantener actualizada la lista de funciones bsicas o de usuario activas. Presentar la lista de funciones en pantalla.

Funcion_Usuario: Define el comportamiento de una funcin de usuario para que l pueda modificar el conjunto existente.

Clase: TFormaArbol Propsito

Colaborar con la interfaz para manipular las funciones activas tanto bsicas como de usuario definidas para la ejecucin de la simulacin.

80

Clase: Sennal Responsabilidades

Superclase:

Subclase: Colaboraciones

Definir las terminales individuos(rboles).

de

los

Clase: sennal Propsito

Definir una seal, de entrada [A..Z] o constante (0,1), generada aleatoriamente o con un valor dado.

Clase: Funcion_Usuario Responsabilidades

Superclase: Colaboraciones

Subclase:

Identificar una funcin creada por el usuario, con nmero de argumentos, salidas y la tabla de verdad correspondiente Manipulacin de los archivos correspondientes

Patron: Define la tabla de verdad de las funciones de usuario activas.

Clase: Funcion_Usuario Propsito

Identificar una funcin definida por el usuario, con un nombre y una tabla de verdad que la identifica, segn el nmero de entradas.

81

Clase: TNodo Responsabilidades

Superclase:

Subclase: Colaboraciones

Representar un nodo constituyente bsico de los rboles. Funcin bsica o de usuario o seal constante

Sennal: Permite que el nodo pueda ser definido como entrada de circuito o seal constante. Funcion_Usuario: Permite que el nodo sea definido como funcin del usuario.

Clase: TNodo Propsito

Definir y distinguir los nodos componentes de los rboles, en funciones (bsicas y de usuario)y terminales (seales de entrada o constantes).

Clase: TCircuito Responsabilidades

Superclase:

Subclase: Colaboraciones

Comunicar la Interfaz con el Algoritmo gentico

TEvalua: Retorna la aptitud de un rbol. TNodo: Devuelve una referencia a un nodo para ser insertado en un rbol. GALIB: Da el comportamiento de los individuos de la poblacin del AG.

Clase: TCircuito Propsito

Interfaz que define el comportamiento del programa gentico con los parmetros dados por el usuario. Se encarga de la creacin de la poblacin inicial de rboles, y de la definicin de la funcin objetivo.

82

Clase: TEvalua Responsabilidades

Superclase:

Subclase: Colaboraciones

Evaluar un rbol con unas Entradas determinadas (Ejecutarlo) Generar la cadena LISP que lo Representa Generar el Cdigo Fuente VHDL correspondiente.

TNodo: Retorna el contenido de un nodo de un rbol. Funcion_Usuario: Define el comportamiento de una funcin dada. GALIB: Define la estructura de un rbol TVariables: Crea variables auxiliares que se insertan en el cdigo VHDL. Sennal: Comportamiento de un nodo terminal

Clase: TEvalua Propsito Recorrer un rbol para efectuar las siguientes tareas: Evaluarlo con unas Entradas determinadas (Ejecutarlo para calcular su aptitud) Generar la cadena LISP que lo Representa y salvarla en un archivo. Generar el Cdigo Fuente VHDL correspondiente y salvarlo en un archivo.

Clase: TVariables Responsabilidades

Superclase:

Subclase: Colaboraciones

Encapsular el comportamiento de una variable auxiliar para ser usada en la generacin de cdigo VHDL

Clase: TVariables Propsito

Comportarse como un tipo de dato alfabtico que representa palabras (nombres de variables auxiliares)

83

Clase: Patron Responsabilidades

Superclase:

Subclase: Colaboraciones

Manipular un patrn de entradas y salidas para una funcin o un circuito.

Clase: Patron Propsito

Identificar un vector de salidas y entradas y manipularlo como un archivo para las funciones y los circuitos definidos por el usuario.

Clase: THilo Responsabilidades

Superclase:

Subclase: Colaboraciones

Trasladar la ejecucin del programa a un proceso asincrnico (hebra)

TCircuito: Recibe una referencia de las estructuras necesarias para la ejecucin del algoritmo. TEvalua: Retorna la cadena LISP y VHDL asociadas al mejor individuo.

Clase: THilo Propsito Ejecutar y controlar la ejecucin del programa gentico.

84

2.3.4.4. Diagrama de Colaboraciones Entre Objetos

Con base a las colaboraciones expuestas anteriormente, la figura 29 muestra el diagrama de colaboraciones entre objetos. Los puntos de salida representan la prestacin de colaboracin al objeto que la recibe.

Figura 29 Diagrama de Colaboraciones Entre Objetos.

2.3.5. Diagrama De Transicin De Estados

En el anlisis de una aplicacin se hace necesario recorrerla por diferentes caminos (walkthrough): imaginar cmo se invoca un servicio, ver que responsabilidades estn implicadas en cada uno de ellos y analizar todos los servicios que pueda prestar ste; es entonces importante realizar un Diagrama de Transicin de Estados (DTE) del Simulador (Figura 30). En dicho diagrama se utilizarn las siguientes convenciones para los estados: (1) (2) (3) (4) (5) (6) Leer tabla de verdad de circuito a buscar. Leer parmetros del algoritmo. Leer y configurar funciones bsicas y del usuario. Ejecutar el algoritmo de programacin gentica. Generar cdigo LISP, VHDL y Estadsticas de la ltima corrida. Guardar Archivos (LISP, VHDL, estadsticas).

85

Figura 30 Diagrama de Transicin de Estados.

2.3.5.1. Descripcin de las Transiciones

1-2,3: Luego de definir la tabla de verdad del circuito buscado, pueden modificarse tanto los parmetros del algoritmo como las funciones que se utilizaran en su ejecucin. 1-4: Luego de definir la tabla de verdad del circuito buscado, puede ejecutarse directamente el algoritmo con los parmetros predefinidos inicialmente. 2,3-1: Puede luego de configurarse los parmetros, cambiar la tabla del circuito buscado, por otro. 2,3-4: Paso de todos los parmetros para iniciar la ejecucin del algoritmo. 4-4: Ejecutar nuevamente el algoritmo (con la poblacin actual o generando una nueva). 4-5: Mostrar los resultados de la programacin gentica (cdigo VHDL, LISP y estadsticas de la ltima corrida). 5-4: Ejecutar nuevamente el algoritmo (con la poblacin actual o generando una nueva). 5-6: Guardar en archivos el cdigo VHDL, LISP y las estadsticas. 6-1: Leer una nueva tabla de verdad para buscar otro circuito. 6-2,3: Cambiar los parmetros del algoritmo gentico para buscar el circuito actual. 6-4: Ejecutar nuevamente el algoritmo (con la poblacin actual o generando una nueva).

2.4. IMPLEMENTACION
2.4.1. Herramientas de Desarrollo

La aplicacin, fue implementada en C++ Builder Server v. 3.0 de Borland International Inc., el cual es una herramienta que permite crear aplicaciones windows de consola GUI a 32 bits en lenguaje de programacin C++, basada en la filosofa RAD (rapid application development). Utiliza un framework escrito en ObjectPascal, diseado alrededor del concepto de propiedades, eventos y mtodos, llamado VCL (visual component library). Los objetos de la VCL constituyen una especie de programacin visual, ya que al crear la aplicacin, estos pueden ser arrastrados hasta alguna forma, generando de manera automtica el cdigo asociado a ellos. Cada aplicacin, est asociada a un proyecto, el cual contiene formas (archivos .dfm) y unidades, las cuales estn compuestas por un archivo de cabecera (.h) y su correspondiente archivo de implementacin (.cpp). 86

2.4.2. Herramientas Adicionales

2.4.2.1. GALIB

Es una librera de componentes de algoritmos genticos, desarrollada por el MIT (Massachusetts Institute of Technology, 1995), versin 2.4. implementada en C++ (Ver Anexos). GAlib contiene un conjunto de objetos de algoritmos genticos en C++. La librera incluye adems herramientas para el uso de algoritmos genticos para efectuar optimizaciones en cualquier programa C++ que use representacin y operadores genticos. En la aplicacin realizada, se usa un cruce en un solo punto y mutacin de sub-arboles definidas en esta librera.
2.4.2.2. Xilinx Foundation Software

Es una herramienta que permite el diseo, simulacin, implementacin y verificacin de circuitos lgicos programables(Ver Anexos), desarrollada por Xilinx Inc.

2.4.2.3. RANDOMLIB

Aunque GALIB provee una gran cantidad de algoritmos para la generacin de nmeros aleatorios, en este proyecto se usa una pequea librera denominada RANDOMLIB. El generador esta basado en un algoritmo publicado originalmente en el libro Toward a Universal Random Number Generator", diseado por George Marsaglia y Arif Zaman. Se utiliza este algoritmo en la versin final de SimEHDL, ya que durante las pruebas realizadas demostr un mejor desempeo con problemas complejos.
2.4.3. Modulo Tablas de Verdad

ste mdulo independiente, no interactua directamente con el simulador, y su tarea bsica consiste en la edicin de archivos que almacenen la tabla de verdad ya sea de un circuito o de una funcin definida por el usuario. Este mdulo es entonces una aplicacin independiente a la que se aplicar el mismo proceso de diseo y anlisis que se llevo a cabo con el simulador.

2.4.3.1. Especificacin de Requerimientos

El mdulo tablas es una aplicacin grfica interactiva, en la cual el usuario puede editar tablas de verdad de m entradas por n salidas, para luego almacenarlas en archivos y permitir su posterior manipulacin. En ella, el usuario podr: 87

Crear nuevas tablas de verdad. Editar una tabla existente Guardar en un archivo una tabla.

2.4.3.2. Clases

2.4.3.2.1. Lista Preliminar de Clases

La siguiente es la lista preliminar de clases halladas al analizar los requerimientos iniciales de la aplicacin: Mdulo Aplicacin Grfica Tabla de Verdad Entradas Salidas Archivo Aplicacin Aplicacin Editor Atributo Atributo Mtodo

Tabla 26 Lista preliminar de clases

2.4.3.2.2. Lista Final de Clases

FrameForm: Forma MDI, contiene los archivos de tablas. MDIEdit: Encapsula el comportamiento de una tabla de verdad. Configura: Valida entradas del usuario.

2.4.3.2.3. Registro de Clases

Las caractersticas de las tarjetas de clases, son las mismas que las descritas para el simulador:

88

Clase: FrameForm

Superclase:

Subclase:

Responsabilidades Colaboraciones Contener los archivos de tablas de MDIEdit: Configura y pasa referencias a una tabla de verdad. verdad. Soportar la aplicacin.

Clase: FrameForm Propsito Dar forma al programa principal y a los eventos de el mismo.

Clase: Patron Responsabilidades

Superclase:

Subclase: Colaboraciones

Manipular un patrn de entradas y salidas para una funcin o un circuito.

Clase: Patron Propsito

Identificar un vector de salidas y entradas y manipularlo como un archivo para las funciones y los circuitos definidos por el usuario.

89

Clase: MDIEdit

Superclase:

Subclase:

Responsabilidades Colaboraciones Encapsular el comportamiento de una Configura: Configura y pasa validacin respecto a nmero de entradas y salidas de tabla de verdad. la tabla de verdad. Manipular el archivo asociado a la Patron: Identifica una tabla de verdad. misma.

Clase: MDIEdit Propsito Manipular una tabla de verdad.

Clase: Configura

Superclase:

Subclase:

Responsabilidades Colaboraciones Validar el ingreso de datos para la creacin de una tabla de verdad (nmero de entradas y salidas).

Clase: Configura Propsito y salidas).

Validar el ingreso de datos para la creacin de una tabla de verdad (nmero de entradas

90

2.4.3.2.4. Diagrama de Colaboraciones Entre Objetos

Con base a las colaboraciones expuestas anteriormente, la figura 31 muestra el diagrama de colaboraciones entre objetos. Los puntos de salida representan la prestacin de colaboracin al objeto que la recibe.

Figura 31 Colaboraciones entre objetos del mdulo Editor de tablas.

2.4.4. Diagrama de Transicin de Estados

El Diagrama de Transicin de Estados (DTE) del Mdulo Editor de Tablas (Figura 32). En dicho diagrama se utilizarn las siguientes convenciones para los estados: (1) Abrir Nueva Tabla de Verdad. (2) Abrir Tabla de Verdad existente. (3) Leer parmetros de creacin de Tabla de Verdad. (4) Editar Tabla de verdad. (5) Grabar en un archivo la Tabla de Verdad actual.

Figura 32 Diagrama de Transicin de Estados.

2.4.4.1. Descripcin de las Transiciones

1,3: Efecta una llamada a la lectura de parmetros para la creacin de una nueva tabla de verdad. 3,4: Enva los parmetros a un formato de tabla de verdad con las caractersticas especificadas. 4,5: Enva los datos modificados a un archivo de Tabla de Verdad. 91

2,4: Enva los datos del Archivo abierto para ser modificados. 5,1-2-4: Regresa a cualquiera de los tres estados (Abrir nuevo, Abrir Existente o Continuar editando la Tabla de Verdad actual).

92

3. PRUEBAS Y RESULTADOS
Las pruebas realizadas sobre la aplicacin, se llevaron a cabo de la siguiente forma: inicialmente, se elabor la tabla de verdad del circuito buscado en el editor de tablas, y se procedi a ejecutar el algoritmo gentico un total de veinte (20) veces con cada uno de los parmetros constantes para todas y cada una de las ejecuciones realizadas, seguidamente se promediaron los resultados arrojados por todas las ejecuciones en cada ejemplo.

3.1. SUMADOR COMPLETO DE 3 BITS Las pruebas se llevaron a cabo inicialmente sobre un circuito sumador 3 entradas donde dos variables de entrada denotadas por X y Y representan los bits significativos que se agregan. La tercera entrada Z representa el bit de arrastre de la posicin previa menos significativa. Se necesitan dos salidas porque la suma aritmtica de tres dgitos binarios varia en valor de 0 a 3 y los binarios 2 3 necesitan dos dgitos las 2 salidas se designan por los smbolos S para la suma y C para el bit de arrastre; la tabla de verdad del sumador completo es como sigue a continuacin. X 0 0 0 0 1 1 1 1 Y 0 0 1 1 0 0 1 1 Z 0 1 0 1 0 1 0 1 S 0 1 1 0 1 0 0 1 C 0 0 0 1 0 1 1 1

Tabla 27 Tabla de verdad del sumador completo de 3 bits Para la ejecucin del algoritmo se defini la siguiente configuracin sin uso de funciones del usuario: Todas las funciones bsicas se encuentran activas. No hay funciones de usuario. Nmero de niveles para la poblacin inicial: cinco (5). Nmero de individuos: cien (100). Porcentaje funcin terminal 80%. Porcentaje entrada - constante 100%. Terminacin por perfeccin. Tipo de seleccin: mejor individuo. Tipo de aptitud: bits correctos. Cruce : 0.98 93

Mutacin : 0.02 Mximo de nivel de castigo: 4. Castigo: 0.05. Porcentaje de intercambio: 0.25 La ejecucin del algoritmo arroja los siguientes datos: Peor aptitud total: Es la aptitud del peor individuo durante toda la ejecucin del algoritmo (la mas cercana a 0). Mejor Aptitud Total: Es la aptitud del mejor individuo durante toda la ejecucin del problema. Promedio Aptitud Inicial: Es el promedio de aptitud de la poblacin inicial generada por el algoritmo. Mejor Aptitud Inicial: Es la aptitud del mejor individuo de la poblacin inicial generada por el algoritmo. Peor Aptitud Inicial: Es la aptitud del peor individuo de la poblacin inicial generada por el algoritmo. Promedio Aptitud Total: Es el promedio de aptitudes de todos los individuos procesados durante la ejecucin del algoritmo. Promedio Mejores Aptitudes: Es el promedio de las aptitudes de los mejores individuos de cada generacin durante la ejecucin del algoritmo. Nmero Cruces: Nmero de operaciones de cruce realizadas durante la ejecucin del algoritmo. Nmero Mutaciones: Nmero de operaciones de mutacin realizadas durante la ejecucin del algoritmo. Nmero Selecciones: Nmero de operaciones de seleccin realizadas durante la ejecucin del algoritmo. Nmero Generaciones Necesarias: Nmero de generaciones necesarias para encontrar al mejor individuo (aptitud = 1) , durante la ejecucin del algoritmo. Tiempo Total en Segundos: Tiempo total en segundos requerido para encontrar al mejor individuo, durante la ejecucin del algoritmo. El comportamiento que se presento durante 20 ejecuciones diferentes se resume en la siguiente tabla, donde cada valor corresponde al promedio de las veinte ejecuciones: Resumen Peor Aptitud Total Mejor Aptitud Total Promedio Aptitud Inicial Mejor Aptitud Inicial Peor Aptitud Inicial Promedio Aptitud Total Promedio Mejores Aptitudes Nmero Cruces Nmero Mutaciones Nmero Selecciones Nmero Generaciones Necesarias Tiempo Total en Segundos Promedio 0,25625 1 0,5749 0,75625 0,25625 0,82599 0,90594 3282,8 5198,4 3351,4 128,9 74,9 94

Tabla 28 Resuman del comportamiento para el sumador de 3 bits A continuacin se presenta un ejemplo resultante de la ejecucin del algoritmo con los parmetros anteriormente mencionados.
3.1.1. Ejemplo Resultante con la Todas las Funciones Bsicas

Cadena LISP: CONCAT(AND(OR(XOR(A)(C))(C))(OR(XOR(OR(AND(C)(C))(B))(XOR(C)(AND(C)(A))))(B)))( XOR(C)(XOR(OR(A)(A))(B))) Estadsticas: Peor Aptitud Total: 0,25 Mejor Aptitud Total: 1 Promedio Aptitud Inicial: 0,546428 Mejor Aptitud Inicial: 0,75 Peor Aptitud Inicial: 0,25 Promedio Aptitud Total: 0,796295 Promedio Mejores Aptitudes: 0,90485 Nmero Cruces: 1718 Nmero Mutaciones: 1152 Nmero Selecciones: 1742 Nmero Generaciones Necesarias: 67 Tiempo Total en Segundos: 35 Cdigo VHDL:
--Estructura principal del programa library IEEE; use IEEE.std_logic_1164.all; ENTITY circuito_3por2_sumacompleto IS PORT ( Entrada : IN STD_LOGIC_VECTOR(2 DOWNTO 0); Salida : OUT STD_LOGIC_VECTOR(1 DOWNTO 0) ); END circuito_3por2_sumacompleto; ARCHITECTURE comportamiento OF circuito_3por2_sumacompleto IS SIGNAL AA : STD_LOGIC; SIGNAL AB : STD_LOGIC; SIGNAL AC : STD_LOGIC; SIGNAL AD : STD_LOGIC; SIGNAL AE : STD_LOGIC; SIGNAL AF : STD_LOGIC; SIGNAL AG : STD_LOGIC; SIGNAL AH : STD_LOGIC;

95

SIGNAL AI : STD_LOGIC; SIGNAL AJ : STD_LOGIC; SIGNAL AK : STD_LOGIC; SIGNAL AL : STD_LOGIC; SIGNAL A : STD_LOGIC; SIGNAL B : STD_LOGIC; SIGNAL C : STD_LOGIC; BEGIN ---Asignacin de entradas del circuito A<=Entrada(0); B<=Entrada(1); C<=Entrada(2); --Asignacin de salidas del circuito AA<=A XOR C; AB<=AA OR C; AC<=C AND C; AD<=AC OR B; AE<=C AND A; AF<=C XOR AE; AG<=AD XOR AF; AH<=AG OR B; AI<=AB AND AH; Salida(0)<=AI; AJ<=A OR A; AK<=AJ XOR B; AL<=C XOR AK; Salida(1)<=AL; END comportamiento;

Con el fin de que se note la importancia de las funciones predefinidas bsicas (para ste caso la compuerta XOR) o las definidas por el usuario, se presenta un resumen de la ejecucin del mismo circuito con idnticas caractersticas obviando el uso de la funcin predefinida bsica XOR. Resumen Peor Aptitud Total Mejor Aptitud Total Promedio Aptitud Inicial Mejor Aptitud Inicial Peor Aptitud Inicial Promedio Aptitud Total Promedio Mejores Aptitudes Nmero Cruces Nmero Mutaciones Nmero Selecciones Nmero Generaciones Necesarias Tiempo Total en Segundos Promedio 0,3125 0,96875 0,52515 0,71875 0,3125 0,8639 0,8944 15886,5 74551,5 16668,5 537,25 1864,25

Tabla 29 Resumen del comportamiento sin utilizar la funcin XOR 96

Luego de comparar la tabla anterior con la tabla correspondiente a el resumen de ejecuciones para el mismo circuito con la funcin XOR, se observa que con el uso de la compuerta XOR la probabilidad de convergencia aumenta considerablemente, por ejemplo el tiempo promedio necesario para la ejecucin del circuito sumador completo con la compuerta XOR fue de 74,9 seg. contra los 1864,25 seg. de la ejecucin del mismo circuito, igual ocurre al confrontar las mejores aptitudes tanto iniciales como totales.
3.1.2. Ejemplo Resultante sin el Uso de la Compuerta XOR

Cadena LISP: CONCAT(AND(AND(OR(C)(B))(OR(AND(OR(OR(OR(AND(A)(AND(B)(C)))(AND(OR(OR(A)( AND(AND(OR(A)(B))(OR(C)(AND(AND(B)(AND(C)(B)))(AND(B)(A)))))(B)))(AND(AND(B)(B)) (B)))(OR(C)(AND(B)(A)))))(B))(B))(OR(C)(C)))(OR(B)(A))))(OR(A)(AND(C)(C))))(AND(OR(N OT(AND(OR(OR(AND(OR(C)(B))(OR(AND(C)(A))(B)))(B))(B))(OR(OR(A)(C))(A))))(AND(B)(A ND(C)(A))))(OR(A)(OR(C)(B)))) Estadsticas: Peor Aptitud Total: 0,3125 Mejor Aptitud Total: 1 Promedio Aptitud Inicial: 0,5369 Mejor Aptitud Inicial: 0,6875 Peor Aptitud Inicial: 0,3125 Promedio Aptitud Total: 0,875165 Promedio Mejores Aptitudes: 0,88709 Nmero Cruces: 20516 Nmero Mutaciones: 60702 Nmero Selecciones: 20956 Nmero Generaciones Necesarias: 403 Tiempo Total en Segundos: 3032 Cdigo VHDL:
--Estructura principal del programa library IEEE; use IEEE.std_logic_1164.all; ENTITY circuito_3por2_sumacompleto IS PORT ( Entrada : IN STD_LOGIC_VECTOR(2 DOWNTO 0); Salida : OUT STD_LOGIC_VECTOR(1 DOWNTO 0) ); END circuito_3por2_sumacompleto; ARCHITECTURE comportamiento OF circuito_3por2_sumacompleto IS SIGNAL AA : STD_LOGIC; SIGNAL AB : STD_LOGIC;

97

SIGNAL AC : STD_LOGIC; SIGNAL AD : STD_LOGIC; SIGNAL AE : STD_LOGIC; SIGNAL AF : STD_LOGIC; SIGNAL AG : STD_LOGIC; SIGNAL AH : STD_LOGIC; SIGNAL AI : STD_LOGIC; SIGNAL AJ : STD_LOGIC; SIGNAL AK : STD_LOGIC; SIGNAL AL : STD_LOGIC; SIGNAL AM : STD_LOGIC; SIGNAL AN : STD_LOGIC; SIGNAL AO : STD_LOGIC; SIGNAL AP : STD_LOGIC; SIGNAL AQ : STD_LOGIC; SIGNAL AR : STD_LOGIC; SIGNAL AS : STD_LOGIC; SIGNAL AT : STD_LOGIC; SIGNAL AU : STD_LOGIC; SIGNAL AV : STD_LOGIC; SIGNAL AW : STD_LOGIC; SIGNAL AX : STD_LOGIC; SIGNAL AY : STD_LOGIC; SIGNAL AZ : STD_LOGIC; SIGNAL BA : STD_LOGIC; SIGNAL BB : STD_LOGIC; SIGNAL BC : STD_LOGIC; SIGNAL BD : STD_LOGIC; SIGNAL BE : STD_LOGIC; SIGNAL BF : STD_LOGIC; SIGNAL BG : STD_LOGIC; SIGNAL BH : STD_LOGIC; SIGNAL BI : STD_LOGIC; SIGNAL BJ : STD_LOGIC; SIGNAL BK : STD_LOGIC; SIGNAL BL : STD_LOGIC; SIGNAL BM : STD_LOGIC; SIGNAL BN : STD_LOGIC; SIGNAL BO : STD_LOGIC; SIGNAL BP : STD_LOGIC; SIGNAL BQ : STD_LOGIC; SIGNAL BR : STD_LOGIC; SIGNAL BS : STD_LOGIC; SIGNAL A : STD_LOGIC; SIGNAL B : STD_LOGIC; SIGNAL C : STD_LOGIC; BEGIN ---Asignacin de entradas del circuito A<=Entrada(0); B<=Entrada(1); C<=Entrada(2); --Asignacin de salidas del circuito AA<=C OR B;

98

AB<=B AND C; AC<=A AND AB; AD<=A OR B; AE<=C AND B; AF<=B AND AE; AG<=B AND A; AH<=AF AND AG; AI<=C OR AH; AJ<=AD AND AI; AK<=AJ AND B; AL<=A OR AK; AM<=B AND B; AN<=AM AND B; AO<=AL OR AN; AP<=B AND A; AQ<=C OR AP; AR<=AO AND AQ; AS<=AC OR AR; AT<=AS OR B; AU<=AT OR B; AV<=C OR C; AW<=AU AND AV; AX<=B OR A; AY<=AW OR AX; AZ<=AA AND AY; BA<=C AND C; BB<=A OR BA; BC<=AZ AND BB; Salida(0)<=BC; BD<=C OR B; BE<=C AND A; BF<=BE OR B; BG<=BD AND BF; BH<=BG OR B; BI<=BH OR B; BJ<=A OR C; BK<=BJ OR A; BL<=BI AND BK; BM<=NOT BL; BN<=C AND A; BO<=B AND BN; BP<=BM OR BO; BQ<=C OR B; BR<=A OR BQ; BS<=BP AND BR; Salida(1)<=BS; END comportamiento;

99

3.1.3. Resultados con Funciones Definidas por el Usuario

Para este caso se definen las funciones de usuario MI_CARRY_SC y MI_SUMA_SC respectivamente cumpliendo la funcin de carry y suma para el sumador de tres bits, las funciones bsicas son inhabilitadas dando como resultados en mas del 80% de los casos una aptitud de uno. Resumen Peor Aptitud Total Mejor Aptitud Total Promedio Aptitud Inicial Mejor Aptitud Inicial Peor Aptitud Inicial Promedio Aptitud Total Promedio Mejores Aptitudes Nmero Cruces Nmero Mutaciones Nmero Selecciones Nmero Generaciones Necesarias Tiempo Total en Segundos Promedio 0,25 1 0,6294 1 0,25 0,65735 1 59 4 34 3 17

Tabla 30 Resumen del comportamiento utilizando funciones de usuario Para este caso se uso un nmero de individuos igual a 50 y mximo de niveles en 3. Como puede observarse la probabilidad de convergencia es mucho mayor, puesto que la cantidad de individuos usados y el mximo de niveles, limitan el comportamiento del algoritmo a un espacio en el que seguramente se podr encontrar la solucin.

3.1.3.1. Ejemplo Resultante Con Funciones de Usuario

Cadena LISP CONCAT(MI_CARRY_SC(A)(MI_SUMA_SC(C)(B)(B))(MI_CARRY_SC(B)(C)(A)))(MI_SUMA_ SC(MI_CARRY_SC(B)(A)(B))(MI_CARRY_SC(C)(B)(B))(MI_SUMA_SC(B)(A)(C))) Estadsticas: Peor Aptitud Total: 0,375 Mejor Aptitud Total: 1 Promedio Aptitud Inicial: 0,60833335 Mejor Aptitud Inicial: 0,875 Peor Aptitud Inicial: 0,375 Promedio Aptitud Total: 0,68738 Promedio Mejores Aptitudes: 0,899999 Nmero Cruces: 128 Nmero Mutaciones: 78 100

Nmero Selecciones: 130 Nmero Generaciones Necesarias: 5 Tiempo Total en Segundos: 28 Cdigo VHDL:
library IEEE; use IEEE.std_logic_1164.all; ENTITY MI_CARRY_SC IS PORT ( Entrada_MI_CARRY_SC : IN STD_LOGIC_VECTOR(2 DOWNTO 0); Salida_MI_CARRY_SC : OUT STD_LOGIC ); END MI_CARRY_SC; ARCHITECTURE comp_MI_CARRY_SC OF MI_CARRY_SC IS BEGIN WITH Entrada_MI_CARRY_SC SELECT Salida_MI_CARRY_SC <= '0' WHEN "000", '0' WHEN "001", '0' WHEN "010", '1' WHEN "011", '0' WHEN "100", '1' WHEN "101", '1' WHEN "110", '1' WHEN "111", '0' WHEN OTHERS; END comp_MI_CARRY_SC; library IEEE; use IEEE.std_logic_1164.all; ENTITY MI_SUMA_SC IS PORT ( Entrada_MI_SUMA_SC : IN STD_LOGIC_VECTOR(2 DOWNTO 0); Salida_MI_SUMA_SC : OUT STD_LOGIC ); END MI_SUMA_SC; ARCHITECTURE comp_MI_SUMA_SC OF MI_SUMA_SC IS BEGIN WITH Entrada_MI_SUMA_SC SELECT Salida_MI_SUMA_SC <= '0' WHEN "000", '1' WHEN "001", '1' WHEN "010", '0' WHEN "011", '1' WHEN "100", '0' WHEN "101",

101

'0' WHEN "110", '1' WHEN "111", '0' WHEN OTHERS; END comp_MI_SUMA_SC; --Estructura principal del programa library IEEE; use IEEE.std_logic_1164.all; ENTITY circuito_3por2_sumacompleto IS PORT ( Entrada : IN STD_LOGIC_VECTOR(2 DOWNTO 0); Salida : OUT STD_LOGIC_VECTOR(1 DOWNTO 0) ); END circuito_3por2_sumacompleto; ARCHITECTURE comportamiento OF circuito_3por2_sumacompleto IS SIGNAL AA : STD_LOGIC; SIGNAL AB : STD_LOGIC; SIGNAL AC : STD_LOGIC; SIGNAL AD : STD_LOGIC; SIGNAL AE : STD_LOGIC; SIGNAL AF : STD_LOGIC; SIGNAL AG : STD_LOGIC; SIGNAL A : STD_LOGIC; SIGNAL B : STD_LOGIC; SIGNAL C : STD_LOGIC; COMPONENT MI_CARRY_SC PORT ( Entrada_MI_CARRY_SC : IN STD_LOGIC_VECTOR(2 DOWNTO 0); Salida_MI_CARRY_SC : OUT STD_LOGIC ); END COMPONENT; COMPONENT MI_SUMA_SC PORT ( Entrada_MI_SUMA_SC : IN STD_LOGIC_VECTOR(2 DOWNTO 0); Salida_MI_SUMA_SC : OUT STD_LOGIC ); END COMPONENT; SIGNAL SIGNAL SIGNAL SIGNAL SIGNAL SIGNAL SIGNAL BEGIN -Temp_0 Temp_1 Temp_2 Temp_3 Temp_4 Temp_5 Temp_6 : STD_LOGIC_VECTOR(2 DOWNTO 0); : STD_LOGIC_VECTOR(2 DOWNTO 0); : STD_LOGIC_VECTOR(2 DOWNTO 0); : STD_LOGIC_VECTOR(2 DOWNTO 0); : STD_LOGIC_VECTOR(2 DOWNTO 0); : STD_LOGIC_VECTOR(2 DOWNTO 0); : STD_LOGIC_VECTOR(2 DOWNTO 0);

102

--Asignacin de entradas del circuito A<=Entrada(0); B<=Entrada(1); C<=Entrada(2); --Asignacin de salidas del circuito Temp_0(0)<=C; Temp_0(1)<=B; Temp_0(2)<=B; INST_0 : MI_SUMA_SC PORT MAP (Temp_0,AA); Temp_1(0)<=B; Temp_1(1)<=C; Temp_1(2)<=A; INST_1 : MI_CARRY_SC PORT MAP (Temp_1,AB); Temp_2(0)<=A; Temp_2(1)<=AA; Temp_2(2)<=AB; INST_2 : MI_CARRY_SC PORT MAP (Temp_2,AC); Salida(0)<=AC; Temp_3(0)<=B; Temp_3(1)<=A; Temp_3(2)<=B; INST_3 : MI_CARRY_SC PORT MAP (Temp_3,AD); Temp_4(0)<=C; Temp_4(1)<=B; Temp_4(2)<=B; INST_4 : MI_CARRY_SC PORT MAP (Temp_4,AE); Temp_5(0)<=B; Temp_5(1)<=A; Temp_5(2)<=C; INST_5 : MI_SUMA_SC PORT MAP (Temp_5,AF); Temp_6(0)<=AD; Temp_6(1)<=AE; Temp_6(2)<=AF; INST_6 : MI_SUMA_SC PORT MAP (Temp_6,AG); Salida(1)<=AG; END comportamiento;

103

3.2. MULTIPLEXOR DE 2 ENTRADAS DE DOS BITS Las pruebas se llevaron a cabo con un circuito de 5 entradas donde dos variables de entrada denotadas por X y Y representan la primera entrada y A y B representan la segunda entrada y la quinta entrada Z representa el bit de eleccin entre las dos entradas XY o AB, C y D son respectivamente las salidas seleccionadas, la tabla de verdad, tiene entonces 32 combinaciones posibles. Para la ejecucin del algoritmo fue definida la siguiente configuracin: Todas las funciones bsicas se encuentran activas. No hay funciones de usuario. Nmero de niveles para la poblacin inicial cinco (3). Nmero de individuos cien (100). Porcentaje funcin terminal 60%. Porcentaje entrada - constante 100%. Terminacin por perfeccin. Tipo de seleccin: mejor individuo. Tipo de aptitud: bits correctos. Cruce : 0.98 Mutacin : 0.02 Mximo de nivel de castigo: 5. Castigo: 0.05. Porcentaje de intercambio: 0.5 Los resultados obtenidos para veinte (20) ejecuciones fueron: Resumen Peor Aptitud Total Mejor Aptitud Total Promedio Aptitud Inicial Mejor Aptitud Inicial Peor Aptitud Inicial Promedio Aptitud Total Promedio Mejores Aptitudes Nmero Cruces Nmero Mutaciones Nmero Selecciones Nmero Generaciones Necesarias Tiempo Total en Segundos Promedio 0,34375 1 0,53854 0,75 0,34375 0, 816862 0,874067 2421.5 3750.2 2556,4 189 674,9

Tabla 31 Resumen del comportamiento para el multiplexor de 2 entradas

104

3.2.1. Ejemplo Resultante

Cadena LISP: CONCAT(AND(OR(C)(OR(AND(OR(E)(A))(C))(OR(C)(NOT(E)))))(AND(OR(E)(A))(OR(C)(OR (A)(AND(AND(C)(C))(AND(OR(A)(B))(B)))))))(NOT(NOT(AND(OR(B)(AND(E)(D)))(OR(D)(N OT(E)))))) Estadsticas: Peor Aptitud Total: 0,3125 Mejor Aptitud Total: 1 Promedio Aptitud Inicial: 0,51875 Mejor Aptitud Inicial: 0,75 Peor Aptitud Inicial: 0,3125 Promedio Aptitud Total: 0,813539 Promedio Mejores Aptitudes: 0,867977 Nmero Cruces: 4542 Nmero Mutaciones: 4956 Nmero Selecciones: 4628 Nmero Generaciones Necesarias: 89 Tiempo Total en Segundos: 287 Cdigo VHDL:
--Estructura principal del programa library IEEE; use IEEE.std_logic_1164.all; ENTITY circuito_multiplexor2x2 IS PORT ( Entrada : IN STD_LOGIC_VECTOR(4 DOWNTO 0); Salida : OUT STD_LOGIC_VECTOR(1 DOWNTO 0) ); END circuito_multiplexor2x2; ARCHITECTURE comportamiento OF circuito_multiplexor2x2 IS SIGNAL AA : STD_LOGIC; SIGNAL AB : STD_LOGIC; SIGNAL AC : STD_LOGIC; SIGNAL AD : STD_LOGIC; SIGNAL AE : STD_LOGIC; SIGNAL AF : STD_LOGIC; SIGNAL AG : STD_LOGIC; SIGNAL AH : STD_LOGIC; SIGNAL AI : STD_LOGIC; SIGNAL AJ : STD_LOGIC; SIGNAL AK : STD_LOGIC; SIGNAL AL : STD_LOGIC; SIGNAL AM : STD_LOGIC; SIGNAL AN : STD_LOGIC;

105

SIGNAL AO : STD_LOGIC; SIGNAL AP : STD_LOGIC; SIGNAL AQ : STD_LOGIC; SIGNAL AR : STD_LOGIC; SIGNAL AS : STD_LOGIC; SIGNAL AT : STD_LOGIC; SIGNAL AU : STD_LOGIC; SIGNAL AV : STD_LOGIC; SIGNAL A : STD_LOGIC; SIGNAL B : STD_LOGIC; SIGNAL C : STD_LOGIC; SIGNAL D : STD_LOGIC; SIGNAL E : STD_LOGIC; BEGIN ---Asignacin de entradas del circuito A<=Entrada(0); B<=Entrada(1); C<=Entrada(2); D<=Entrada(3); E<=Entrada(4); --Asignacin de salidas del circuito AA<=E OR A; AB<=AA AND C; AC<=NOT E; AD<=C OR AC; AE<=AB OR AD; AF<=C OR AE; AG<=E OR A; AH<=C AND C; AI<=A OR B; AJ<=AI AND B; AK<=AH AND AJ; AL<=A OR AK; AM<=C OR AL; AN<=AG AND AM; AO<=AF AND AN; Salida(0)<=AO; AP<=E AND D; AQ<=B OR AP; AR<=NOT E; AS<=D OR AR; AT<=AQ AND AS; AU<=NOT AT; AV<=NOT AU; Salida(1)<=AV; END comportamiento;

106

3.2.2.Ejemplo con Funciones de Usuario

Para este caso se trabajo con la compuerta OR bsica y la funcin predefinida Andanotb la cual es una compuerta AND con la segunda entrada negada. Cadena LISP: CONCAT(OR(andanotb(andanotb(andanotb(C)(andanotb(B)(E)))(andanotb(C)(A)))(D))(OR(and anotb(andanotb(andanotb(A)(andanotb(C)(C)))(E))(andanotb(andanotb(andanotb(andanotb(and anotb(C)(A))(andanotb(D)(andanotb(E)(E))))(andanotb(andanotb(C)(andanotb(C)(C)))(andanot b(C)(A))))(C))(andanotb(OR(C)(E))(B))))(andanotb(C)(andanotb(C)(E)))))(OR(andanotb(E)(and anotb(andanotb(E)(andanotb(D)(andanotb(andanotb(andanotb(C)(andanotb(D)(A)))(C))(andan otb(C)(C)))))(andanotb(andanotb(andanotb(C)(andanotb(D)(A)))(andanotb(C)(A)))(OR(E)(A)))) )(OR(andanotb(B)(E))(andanotb(andanotb(B)(E))(andanotb(andanotb(andanotb(A)(andanotb(B) (E)))(E))(E))))) Estadsticas: Peor Aptitud Total: 0,375 Mejor Aptitud Total: 1 Promedio Aptitud Inicial: 0,579465 Mejor Aptitud Inicial: 0,75 Peor Aptitud Inicial: 0,375 Promedio Aptitud Total: 0,89277 Promedio Mejores Aptitudes: 0,911458 Nmero Cruces: 11926 Nmero Mutaciones: 23854 Nmero Selecciones: 12168 Nmero Generaciones Necesarias: 234 Tiempo Total en Segundos: 619 Cdigo VHDL:
library IEEE; use IEEE.std_logic_1164.all; ENTITY andanotb IS PORT ( Entrada_andanotb : IN STD_LOGIC_VECTOR(1 DOWNTO 0); Salida_andanotb : OUT STD_LOGIC ); END andanotb; ARCHITECTURE comp_andanotb OF andanotb IS BEGIN WITH Entrada_andanotb SELECT Salida_andanotb <= '0' WHEN "00",

107

'0' WHEN "01", '1' WHEN "10", '0' WHEN "11", '0' WHEN OTHERS; END comp_andanotb; --Estructura principal del programa library IEEE; use IEEE.std_logic_1164.all; ENTITY circuito_multiplexor2x2 IS PORT ( Entrada : IN STD_LOGIC_VECTOR(4 DOWNTO 0); Salida : OUT STD_LOGIC_VECTOR(1 DOWNTO 0) ); END circuito_multiplexor2x2; ARCHITECTURE comportamiento OF circuito_multiplexor2x2 IS SIGNAL AA : STD_LOGIC; SIGNAL AB : STD_LOGIC; SIGNAL AC : STD_LOGIC; SIGNAL AD : STD_LOGIC; SIGNAL AE : STD_LOGIC; SIGNAL AF : STD_LOGIC; SIGNAL AG : STD_LOGIC; SIGNAL AH : STD_LOGIC; SIGNAL AI : STD_LOGIC; SIGNAL AJ : STD_LOGIC; SIGNAL AK : STD_LOGIC; SIGNAL AL : STD_LOGIC; SIGNAL AM : STD_LOGIC; SIGNAL AN : STD_LOGIC; SIGNAL AO : STD_LOGIC; SIGNAL AP : STD_LOGIC; SIGNAL AQ : STD_LOGIC; SIGNAL AR : STD_LOGIC; SIGNAL AS : STD_LOGIC; SIGNAL AT : STD_LOGIC; SIGNAL AU : STD_LOGIC; SIGNAL AV : STD_LOGIC; SIGNAL AW : STD_LOGIC; SIGNAL AX : STD_LOGIC; SIGNAL AY : STD_LOGIC; SIGNAL AZ : STD_LOGIC; SIGNAL BA : STD_LOGIC; SIGNAL BB : STD_LOGIC; SIGNAL BC : STD_LOGIC; SIGNAL BD : STD_LOGIC; SIGNAL BE : STD_LOGIC; SIGNAL BF : STD_LOGIC;

108

SIGNAL SIGNAL SIGNAL SIGNAL SIGNAL SIGNAL SIGNAL SIGNAL SIGNAL SIGNAL SIGNAL SIGNAL SIGNAL SIGNAL SIGNAL SIGNAL SIGNAL SIGNAL SIGNAL SIGNAL SIGNAL SIGNAL SIGNAL

BG BH BI BJ BK BL BM BN BO BP BQ BR BS BT BU BV BW BX A B C D E

: STD_LOGIC; : STD_LOGIC; : STD_LOGIC; : STD_LOGIC; : STD_LOGIC; : STD_LOGIC; : STD_LOGIC; : STD_LOGIC; : STD_LOGIC; : STD_LOGIC; : STD_LOGIC; : STD_LOGIC; : STD_LOGIC; : STD_LOGIC; : STD_LOGIC; : STD_LOGIC; : STD_LOGIC; : STD_LOGIC; : STD_LOGIC; : STD_LOGIC; : STD_LOGIC; : STD_LOGIC; : STD_LOGIC;

COMPONENT andanotb PORT ( Entrada_andanotb : IN STD_LOGIC_VECTOR(1 DOWNTO 0); Salida_andanotb : OUT STD_LOGIC ); END COMPONENT; SIGNAL SIGNAL SIGNAL SIGNAL SIGNAL SIGNAL SIGNAL SIGNAL SIGNAL SIGNAL SIGNAL SIGNAL SIGNAL SIGNAL SIGNAL SIGNAL SIGNAL SIGNAL SIGNAL SIGNAL Temp_0 Temp_1 Temp_2 Temp_3 Temp_4 Temp_5 Temp_6 Temp_7 Temp_8 Temp_9 Temp_10 Temp_11 Temp_12 Temp_13 Temp_14 Temp_15 Temp_16 Temp_17 Temp_18 Temp_19 : STD_LOGIC_VECTOR(1 DOWNTO 0); : STD_LOGIC_VECTOR(1 DOWNTO 0); : STD_LOGIC_VECTOR(1 DOWNTO 0); : STD_LOGIC_VECTOR(1 DOWNTO 0); : STD_LOGIC_VECTOR(1 DOWNTO 0); : STD_LOGIC_VECTOR(1 DOWNTO 0); : STD_LOGIC_VECTOR(1 DOWNTO 0); : STD_LOGIC_VECTOR(1 DOWNTO 0); : STD_LOGIC_VECTOR(1 DOWNTO 0); : STD_LOGIC_VECTOR(1 DOWNTO 0); : STD_LOGIC_VECTOR(1 DOWNTO 0); : STD_LOGIC_VECTOR(1 DOWNTO 0); : STD_LOGIC_VECTOR(1 DOWNTO 0); : STD_LOGIC_VECTOR(1 DOWNTO 0); : STD_LOGIC_VECTOR(1 DOWNTO 0); : STD_LOGIC_VECTOR(1 DOWNTO 0); : STD_LOGIC_VECTOR(1 DOWNTO 0); : STD_LOGIC_VECTOR(1 DOWNTO 0); : STD_LOGIC_VECTOR(1 DOWNTO 0); : STD_LOGIC_VECTOR(1 DOWNTO 0);

109

SIGNAL Temp_20 : STD_LOGIC_VECTOR(1 DOWNTO 0); SIGNAL Temp_21 : STD_LOGIC_VECTOR(1 DOWNTO 0); SIGNAL Temp_22 : STD_LOGIC_VECTOR(1 DOWNTO 0); SIGNAL Temp_23 : STD_LOGIC_VECTOR(1 DOWNTO 0); SIGNAL Temp_24 : STD_LOGIC_VECTOR(1 DOWNTO 0); SIGNAL Temp_25 : STD_LOGIC_VECTOR(1 DOWNTO 0); SIGNAL Temp_26 : STD_LOGIC_VECTOR(1 DOWNTO 0); SIGNAL Temp_27 : STD_LOGIC_VECTOR(1 DOWNTO 0); SIGNAL Temp_28 : STD_LOGIC_VECTOR(1 DOWNTO 0); SIGNAL Temp_29 : STD_LOGIC_VECTOR(1 DOWNTO 0); SIGNAL Temp_30 : STD_LOGIC_VECTOR(1 DOWNTO 0); SIGNAL Temp_31 : STD_LOGIC_VECTOR(1 DOWNTO 0); SIGNAL Temp_32 : STD_LOGIC_VECTOR(1 DOWNTO 0); SIGNAL Temp_33 : STD_LOGIC_VECTOR(1 DOWNTO 0); SIGNAL Temp_34 : STD_LOGIC_VECTOR(1 DOWNTO 0); SIGNAL Temp_35 : STD_LOGIC_VECTOR(1 DOWNTO 0); SIGNAL Temp_36 : STD_LOGIC_VECTOR(1 DOWNTO 0); SIGNAL Temp_37 : STD_LOGIC_VECTOR(1 DOWNTO 0); SIGNAL Temp_38 : STD_LOGIC_VECTOR(1 DOWNTO 0); SIGNAL Temp_39 : STD_LOGIC_VECTOR(1 DOWNTO 0); SIGNAL Temp_40 : STD_LOGIC_VECTOR(1 DOWNTO 0); SIGNAL Temp_41 : STD_LOGIC_VECTOR(1 DOWNTO 0); SIGNAL Temp_42 : STD_LOGIC_VECTOR(1 DOWNTO 0); SIGNAL Temp_43 : STD_LOGIC_VECTOR(1 DOWNTO 0); BEGIN ---Asignacin de entradas del circuito A<=Entrada(0); B<=Entrada(1); C<=Entrada(2); D<=Entrada(3); E<=Entrada(4); --Asignacin de salidas del circuito Temp_0(0)<=B; Temp_0(1)<=E; INST_0 : andanotb PORT MAP (Temp_0,AA); Temp_1(0)<=C; Temp_1(1)<=AA; INST_1 : andanotb PORT MAP (Temp_1,AB); Temp_2(0)<=C; Temp_2(1)<=A; INST_2 : andanotb PORT MAP (Temp_2,AC); Temp_3(0)<=AB; Temp_3(1)<=AC; INST_3 : andanotb PORT MAP (Temp_3,AD); Temp_4(0)<=AD; Temp_4(1)<=D; INST_4 : andanotb PORT MAP (Temp_4,AE); Temp_5(0)<=C;

110

Temp_5(1)<=C; INST_5 : andanotb PORT MAP (Temp_5,AF); Temp_6(0)<=A; Temp_6(1)<=AF; INST_6 : andanotb PORT MAP (Temp_6,AG); Temp_7(0)<=AG; Temp_7(1)<=E; INST_7 : andanotb PORT MAP (Temp_7,AH); Temp_8(0)<=C; Temp_8(1)<=A; INST_8 : andanotb PORT MAP (Temp_8,AI); Temp_9(0)<=E; Temp_9(1)<=E; INST_9 : andanotb PORT MAP (Temp_9,AJ); Temp_10(0)<=D; Temp_10(1)<=AJ; INST_10 : andanotb PORT MAP (Temp_10,AK); Temp_11(0)<=AI; Temp_11(1)<=AK; INST_11 : andanotb PORT MAP (Temp_11,AL); Temp_12(0)<=C; Temp_12(1)<=C; INST_12 : andanotb PORT MAP (Temp_12,AM); Temp_13(0)<=C; Temp_13(1)<=AM; INST_13 : andanotb PORT MAP (Temp_13,AN); Temp_14(0)<=C; Temp_14(1)<=A; INST_14 : andanotb PORT MAP (Temp_14,AO); Temp_15(0)<=AN; Temp_15(1)<=AO; INST_15 : andanotb PORT MAP (Temp_15,AP); Temp_16(0)<=AL; Temp_16(1)<=AP; INST_16 : andanotb PORT MAP (Temp_16,AQ); Temp_17(0)<=AQ; Temp_17(1)<=C; INST_17 : andanotb PORT MAP (Temp_17,AR); AS<=C OR E; Temp_18(0)<=AS;

111

Temp_18(1)<=B; INST_18 : andanotb PORT MAP (Temp_18,AT); Temp_19(0)<=AR; Temp_19(1)<=AT; INST_19 : andanotb PORT MAP (Temp_19,AU); Temp_20(0)<=AH; Temp_20(1)<=AU; INST_20 : andanotb PORT MAP (Temp_20,AV); Temp_21(0)<=C; Temp_21(1)<=E; INST_21 : andanotb PORT MAP (Temp_21,AW); Temp_22(0)<=C; Temp_22(1)<=AW; INST_22 : andanotb PORT MAP (Temp_22,AX); AY<=AV OR AX; AZ<=AE OR AY; Salida(0)<=AZ; Temp_23(0)<=D; Temp_23(1)<=A; INST_23 : andanotb PORT MAP (Temp_23,BA); Temp_24(0)<=C; Temp_24(1)<=BA; INST_24 : andanotb PORT MAP (Temp_24,BB); Temp_25(0)<=BB; Temp_25(1)<=C; INST_25 : andanotb PORT MAP (Temp_25,BC); Temp_26(0)<=C; Temp_26(1)<=C; INST_26 : andanotb PORT MAP (Temp_26,BD); Temp_27(0)<=BC; Temp_27(1)<=BD; INST_27 : andanotb PORT MAP (Temp_27,BE); Temp_28(0)<=D; Temp_28(1)<=BE; INST_28 : andanotb PORT MAP (Temp_28,BF); Temp_29(0)<=E; Temp_29(1)<=BF; INST_29 : andanotb PORT MAP (Temp_29,BG); Temp_30(0)<=D;

112

Temp_30(1)<=A; INST_30 : andanotb PORT MAP (Temp_30,BH); Temp_31(0)<=C; Temp_31(1)<=BH; INST_31 : andanotb PORT MAP (Temp_31,BI); Temp_32(0)<=C; Temp_32(1)<=A; INST_32 : andanotb PORT MAP (Temp_32,BJ); Temp_33(0)<=BI; Temp_33(1)<=BJ; INST_33 : andanotb PORT MAP (Temp_33,BK); BL<=E OR A; Temp_34(0)<=BK; Temp_34(1)<=BL; INST_34 : andanotb PORT MAP (Temp_34,BM); Temp_35(0)<=BG; Temp_35(1)<=BM; INST_35 : andanotb PORT MAP (Temp_35,BN); Temp_36(0)<=E; Temp_36(1)<=BN; INST_36 : andanotb PORT MAP (Temp_36,BO); Temp_37(0)<=B; Temp_37(1)<=E; INST_37 : andanotb PORT MAP (Temp_37,BP); Temp_38(0)<=B; Temp_38(1)<=E; INST_38 : andanotb PORT MAP (Temp_38,BQ); Temp_39(0)<=B; Temp_39(1)<=E; INST_39 : andanotb PORT MAP (Temp_39,BR); Temp_40(0)<=A; Temp_40(1)<=BR; INST_40 : andanotb PORT MAP (Temp_40,BS); Temp_41(0)<=BS; Temp_41(1)<=E; INST_41 : andanotb PORT MAP (Temp_41,BT); Temp_42(0)<=BT; Temp_42(1)<=E; INST_42 : andanotb PORT MAP (Temp_42,BU); Temp_43(0)<=BQ;

113

Temp_43(1)<=BU; INST_43 : andanotb PORT MAP (Temp_43,BV); BW<=BP OR BV; BX<=BO OR BW; Salida(1)<=BX; END comportamiento;

114

LOGROS
Para el desarrollo de la presente investigacin, se planteo inicialmente la simulacin de un circuito sumador, que por definicin consta de elementos digitales sencillos como son las compuertas AND y XOR. Para el estudio del comportamiento de este dispositivo, una de las primeras etapas en la recopilacin de informacin abarco el estudio de circuitos lgicos combinatorios, de la cual se concluy que la simulacin del circuito sumador por medio de rboles(aprovechando el potencial de la programacin gentica) implicaba la creacin y uso de nuevas funciones lgicas como son la compuerta OR y la compuerta NOT; adems de la manipulacin de seales binarias de entrada y salida. De aqu se desprende entonces que la caracterstica principal de un circuito combinatorio radica en que la(s) salida(s) del circuito solo dependen de las combinaciones de las entradas sin tener en cuenta ningn estado anterior del circuito. Entonces el recorrido del rbol indicar el comportamiento del circuito. Sin embargo, la estructura del rbol solo es modificada por el nmero de salidas del circuito, el nmero de entradas y las funciones lgicas involucradas; Por tanto si estos datos son variables y se tiene a la vez control sobre ellos, tericamente cualquier circuito combinatorio podra ser encontrado por la simulacin. Es as como en la aplicacin final, el nmero de funciones bsicas aumenta, y adems el usuario puede crear sus propias funciones, lo cual permite resolver una amplia gama de circuitos combinatorios, donde la nica restriccin radica en el tamao en memoria necesario para representar el circuito buscado, ya que en la programacin gentica, el tiempo de respuesta y el manejo de memoria se ven afectados por el tamao de la poblacin y el tamao de cada individuo (representados internamente como arboles n-arios). Otro logro obtenido, radica en el tipo de dispositivo capaz de aceptar la configuracin resultante dada por la aplicacin. En primera instancia se plante el uso exclusivo de circuitos FPGA, con la intencin de poder modificar directamente la estructura que defina el circuito, el cual debe ser fiel a un File description (archivo de configuracion) propio de Xilinx, y cuya estructura no es del dominio pblico por obvias razones. Entonces, al investigar los diversos mtodos existentes para la programacin de un circuito FPGA y gracias a la informacin facilitada va Internet y correo certificado por XILINX, se lleg a la conclusin que una forma eficiente y por dems interesante sera el uso de lenguajes de alto nivel para la descripcin de hardware VHDL (VHSIC Hardware Description Lenguage), siguiendo los estndares bsicos de la IEEE. SimEHDL trabaja conjuntamente con el software Foundation de Xilinx, el cual recibe el cdigo VHDL sintcticamente correcto y es capaz de simular, implementar y configurar una gran cantidad de circuitos. Dicho software fue usado en la presente investigacin para la realizacin de las diferentes pruebas realizadas. A continuacin se detalla en forma porcentual, cada uno de los objetivos propuestos y su cumplimiento:

115

1. Disear e implementar un simulador para la construccin de circuitos combinacionales por medio de algoritmos genticos con aplicacin a un sumador de 3 bits, orientado a dispositivos reprogramables. Cumplimiento: 100%. Aclaracin: El simulador no slo encuentra el circuito sumador de 3 bits, tambin encuentra cualquier circuito combinatorio con ciertas restricciones de tamao, como son: nmero mximo de salidas, numero mximo de entrada y cantidad de funciones involucradas. 2. Disear el software necesario para simular los componentes esenciales del dispositivo lgico programable (FPGA) para un circuito sumador de 3 bits. Cumplimiento: 100% Aclaracin: Al realizar la respectiva investigacin con respecto a los circuitos FPGA, se encontr que por restricciones de derechos de autor, no era posible realizar el desarrollo del algoritmo gentico directamente sobre la cadena de bits que configuran el FPGA, por ello se decidi atacar el problema, con la poderosa herramienta VHDL, lenguaje de programacin que proporciona independencia sobre el circuito programable usado, con lo cual se gan en alcance del proyecto, ya que este lenguaje puede describir diferente tipos de circuitos de diferentes proveedores. 3. Analizar y disear un algoritmo gentico capaz de programar el dispositivo lgico programable (FPGA) simulado para el sumador de 3 bits. Cumplimiento: 100% 4. Disear e implementar una Interface capaz de interactuar con el algoritmo gentico y el software simulador de FPGA para el sumador de 3 bits. Cumplimiento: 100%

116

CONCLUSIONES Y RECOMENDACIONES
La investigacin en torno al tema de Hardware Evolutivo apenas comienza en la Universidad Nacional de Colombia. Se espera que con el uso adecuado de los circuitos adquiridos por ella y de aplicaciones como la presente, estudiantes y docentes de la Facultad de Ingeniera y otras se interesen en todo el conjunto de aplicaciones que se pueden realizar. Como se plantea en la recopilacin terica, ste trabajo pertenece al nivel de Hardware Evolutivo Extrnseco (OFFLINE), donde la evolucin de los individuos se lleva a cabo en una mquina (PC) diferente al dispositivo que se desea configurar. As entonces el siguiente paso lgico para continuar con el proceso de esta investigacin, es el clculo de la aptitud dentro del dispositivo reprogramable, con pequeas modificaciones a esta aplicacin y con los implementos necesarios (Hardware y Software) se puede llevar a cabo una aproximacin en paralelo calculando la aptitud de varios individuos a la vez en un mismo dispositivo reprogramable. El paso siguiente es la creacin de una aplicacin que permita la configuracin a bajo de nivel de un dispositivo reprogramable. Para esto, se necesitaran, por ejemplo circuitos FPGA XC7000 que pueden ser configurados parcialmente. Con esto, se puede programar una parte del circuito que corresponde a las interfaces I/O, y otras secciones se hacen evolucionar. El circuito se usara entonces para el clculo de la aptitud, pero el algoritmo gentico seguira ejecutndose sobre un PC. Por ltimo, la aplicacin ms interesante seria interdisciplinaria. El diseo del programa gentico dentro del dispositivo programable (Hardware Evolutivo Intrnseco). Existe una gran cantidad de informacin en Internet acerca de circuitos que se configuran por s solos con capacidad de autoreparacin, usando un algoritmo gentico.

117

BIBLIOGRAFIA
[1] MARTINEZ, J.J., Notas de clase Programacin Evolutiva, 1998. [2] KOZA, JOHN R., Hierarchical Automatic Function Definition in Genetic Programming, Standford University, 1998. [3] KOZA, JOHN R., The Genetic Programming Paradigm: Genetically Breedin Populations of Computer Programs to Solve Problems, Standford University, 1998. [4] PRESSMAN, ROGER S., Ingeniera del Software: Un enfoque practico, McGrawHill Interamericana, Espaa, 1993. [5] MAANA, GABRIEL, Memorias del Curso de Anlisis y Diseo Orientados por Objetos (ADOO), Universidad Nacional de Colombia, 1994. [6]GALIB, MIT Direccin Internet: http://lancet.mit.edu/ga/ [7] SANCHEZ, EDUARDO, Field Programmable Gate Array (FPGA) Circuits, En: Towards Evolvable Hardware, The Evolutionary Engineering Approach, SANCHEZ EDUARDO, TOMASSINI MARCO, Ed. Springer_Verlag, Berlin, 1996. [8] XILINX INC. AppLINX CD-ROM, Rev. 9 First Quarter 1999. [9] XILINX INC: The Programmable Logic Data Book, Xilinx, USA, 1998. [10] MORRIS MANO, M., Lgica Digital y Diseo de Computadores, Prentice-Hall Hispanoamericana, Mexico, 1982. [11] TOCCI, ROLAND J., Sistemas Digitales, Prentice-Hall Hispanoamericana, Mexico, 1993. [12] GARZON, MAX. Models of Massive Parallelism, Ed. Springer-Verlag Berlin, 1995. [13] LANGTON, CHRISTOPHER G. Artifitial Life, The MIT Press, Cambridge, Massachusetts, 1995. [14] HIGUCHI T, et al., Evolvable Systems From Biology to Hardware, Ed. Springer-Verlag, Berlin 1990. [15] THOMPSON, ADRIAN. Artificial evolution in the physical world, University of Sussex. [16] HIGUCHI T, et al., Evolvable Harware, en Massively Parallel Artificial Intelligence, MIT Press, 1994. [17] www.vhdl.org Direccin electrnica de la organizacin VHDL. [18] www.geneticprogramming.org 118

[19] www.geneticprogramming.com

119

MANUAL DEL USUARIO

Sim-EHDL es una herramienta que permite el diseo de circuitos combinacionales, al generar el cdigo del circuito buscado en lenguaje VHDL, esto se logra gracias a la programacin gentica, la aplicacin comprende dos programas: Sim-EHDL (la simulacin como tal) y Editor de Tablas, los cuales son explicados a continuacin, con el seguimiento a un ejemplo prctico.

EDITOR DE TABLAS
Para cualquier circuito que se busque, es necesario inicialmente construir la tabla de verdad que lo representa, esa es la tarea del Editor de Tablas de Verdad.

Para crear la tabla de verdad del circuito buscado, se selecciona la opcin Nuevo del men Abrir. Aparece entonces la pantalla siguiente, en la cual los datos esperados corresponden a la cantidad de entradas y salidas del circuito buscado. El cuadro de Inicializacin, corresponde a s las salidas son puestas todas en 1 o 0 respectivamente

Aparece entonces la siguiente ventana dividida en dos tablas, la del lado izquierdo corresponde a las entradas y todas sus combinaciones (no son modificables), y el lado derecho corresponde a las 120

salidas para la combinacin de entradas en la misma fila, las cuales se modifican con un clic izquierdo del ratn sobre la casilla deseada. Una vez editada la tabla de verdad deseada, se procede a salvar su contenido en un archivo con extensin .tdv por cualquiera de las opciones Guardar o Guardar Como del men Archivo.

Con el archivo .tdv creado el usuario puede programar con la aplicacin SimEHDL

Sim-EHDL
Este programa, recibe la Tabla de Verdad del circuito buscado y por medio de la configuracin de un algoritmo de programacin gentica, realiza la bsqueda del mejor programa VHDL que da solucin al problema.

Para iniciar entonces en el men Archivo seleccione la opcin Nuevo Proyecto o Abrir (en caso de que ya existan proyectos creados de extensin .cfg, estos archivos, guardan todos los datos de configuracin de un algoritmo gentico), con lo cual se abren las siguientes ventanas: Funciones Lgicas y Parmetros, luego de modificadas estas, puede entonces definirse el problema a resolver, en la opcin Definir Problema del men Problema, que no es otra que la tabla de verdad del circuito buscado. 121

Ventana de Funciones Lgicas

En ella se pueden observar las funciones bsicas que utiliza el algoritmo, adems de las funciones del usuario. El usuario puede definir una funcin de manera muy simple, consistente en la edicin de una tabla de verdad para la funcin que desea implementar en el Editor de Tablas, con la nica restriccin de que esta solo puede tener una salida.

Para Insertar nuevas funciones, seleccione una de las dos opciones Bsicas o Definidas y con el botn Insertar aparecer segn el caso o la lista de funciones bsicas (AND, OR, XOR, NOT) o el directorio para seleccionar un archivo .tdv. As, si desea desactivar una funcin ya sea bsica o definida, lo que debe hacer es: 1. Ubicarse con el ratn sobre la funcin que desea desactivar y con un clic izquierdo seleccionarla. 2. Luego con el botn Remover, se saca de la lista la funcin seleccionada.

Ventana de Parmetros
En ella se configura el algoritmo de programacin gentica, esta dividida en cuatro partes, descritas a continuacin: 1. Creacin de la poblacin inicial:

Nmero de Niveles: Corresponde al mximo nmero de niveles de profundidad que lograr la poblacin inicial, acepta un rango de valores de 1 a 10 (sin contar la raz del rbol). 122

 Nmero de Individuos: Es el nmero de individuos (rboles) en la poblacin inicial y subsiguientes, acepta un rango de valores entre 1 y 100. Porcentaje Funcin-Terminal: Corresponde a una probabilidad , que segn su valor coloca o no funciones o terminales en algn nivel del rbol generado, por ejemplo si el valor es de 100% en Funcin, los rboles generados en la primera generacin, tendrn todos sus niveles llenos hasta la profundidad mxima, este parmetro permite un mayor grado de aleatoriedad en la creacin de la poblacin inicial. Porcentaje Entrada-Constante: Permite el uso de las variables de entrada (A, B, C.. Z as como entradas tenga el circuito buscado) y valores constantes 1 0. El valor por defecto es 100% en Entradas. Porcentaje Bsicas-Usuario: sta se refiere a la probabilidad con que sern elegidas las funciones bsicas o de usuario para la generacin de la poblacin inicial de rboles. 2. Programa Gentico: General:

Nmero de Generaciones: Corresponde al nmero generaciones durante el cual se ejecutar el algoritmo de programacin gentica. Su rango es de 1 a 3000. Terminacin: Se refiere a la condicin de terminacin del algoritmo. Se tienen las opciones: 1.Perfeccin: detiene la ejecucin tan pronto se encuentre un individuo con aptitud perfecta. 2. Nmero de Generaciones: el algoritmo se ejecuta hasta que se cumpla la cantidad de generaciones establecidas. 3. Convergencia: Segn valores configurados, se detiene si no mejora la aptitud del mejor individuo tras un nmero dado de generaciones en un radio determinado. Tipo de Seleccin: Activa uno de tres tipos de seleccin definidos (MEJOR INDIVIDUO, RULETA y TORNEO). Circuitos Combinatorios: define la forma en que se calculara la aptitud de un individuo, bien sea por nmero de bits correctos o por nmero de palabras correctas, para el primero, es posible adems incluir un castigo para los individuos que sobrepasen el tamao en niveles definido (Nmero Mximo), el castigo no debe ser mayor o igual a 1.

123

3. Programa Gentico: Probabilidades:

Bsicas: definen las probabilidades para el algoritmo de programacin gentica, como son cruce, mutacin y reemplazo de poblacin. Convergencia: Define los valores para la terminacin por convergencia.

4. Manejo de Archivos:

Cada CheckBox activa la opcin de generar el archivo con la extensin respectiva y con el mismo nombre de la tabla de verdad del circuito buscado.

Ejecucin del Algoritmo

Una vez definidos los parmetros de ejecucin y la tabla de verdad del circuito a buscar se proceder a ejecutar el algoritmo con la opcin Ejecutar del men Ejecutar. Durante la ejecucin sta puede ser pausada o abortada (terminada). Mientras el algoritmo se ejecuta, dos ventanas presentan el estado del mismo, ellas son: Seguimiento del Programa y Grfica de Aptitud (Con la grfica de Aptitud del mejor individuo Vs. Generacin).

124

Al terminar la ejecucin del algoritmo, en el men resultados se pueden activar las siguientes ventanas: cdigo LISP, Cdigo VHDL, Grfica de Estadsticas y Archivo de Estadsticas.

125

126

La Opcin Encadenar del Men

A pesar de que el cdigo VHDL final es sintcticamente correcto, es necesario probarlo, para ello la opcin Encadenar facilita la interaccin con el Xilinx Foundation Software de la siguiente manera: Inicialmente Xilinx Foundation supone la existencia de varias entidades en el proceso de sntesis, y es en ese momento en el cual el compilador de Xilinx Foundation necesita saber cual es la entidad principal, y al encadenar, lo que se esta haciendo es crear un archivo de opciones de Xilinx Foundation para que reconozca como entidad principal el circuito que se acaba de disear. Adems se almacena el cdigo VHDL generado dentro del proyecto Foundation. Con este procedimiento, el usuario puede usar el programa como una macro o un componente dentro de su diseo.

INSTALACION Para instalar el software necesario para la ejecucin de SimEHDL y del Editor de Tablas, Inserte el CD-ROM con el software de instalacin, lea el archivo LEAME.TXT, el cual contiene la descripcin de los pasos a seguir.

127

128

HOJA TECNICA

PROCESADOR: Pentium 200 Mhz o superior PANTALLA: SVGA MEMORIA: 64 MB ESPACIO EN DISCO DURO: 6MB SISTEMA OPERATIVO: Microsoft Windows 95/98 OTRO SOFTWARE: Internet Explorer 4.0 o superior

129

ANEXOS

ANEXO A. METODOLOGIA DE ANALISIS Y DISEO

La metodologa que se aplico para las fases de anlisis y diseo del problema, combina la ingeniera de software tradicional con el ciclo de vida propuesto en el documento de G. Maana[5], el cual abarca las siguientes actividades: Ingeniera y anlisis del sistema: Fase en la cual se establecen los requisitos iniciales del sistema, es decir lo que se espera que ste haga, en relacin con le hardware en el que operar y las personas que lo usarn. Diseo: Segn Pressman[4], el diseo del software se centra en ...cuatro atributos distintos del programa: la estructura de los datos, la arquitectura del software, el detalle procedimental y la caracterizacin de la interfaz..., as, el diseo consiste en presentar en forma ms detallada los requerimientos definidos en el paso anterior, organizndolos con respecto a los cuatro tpicos enunciados anteriormente. Implementacin: Es la traduccin del diseo a un lenguaje de programacin (codificacin). Prueba: Pressman[4] enuncia en este sentido: ...Una vez que se ha generado el cdigo, comienza la prueba del programa. La prueba se centra en la lgica interna del software, asegurando que todas las sentencias se han probado..., con el fin de evaluar que el software responde a una entrada definida con los resultados realmente deseados. Mantenimiento: Esta fase implica que el software seguir cambiando o mejorando al ser necesarios nuevos mdulos, o al cambiar los requerimientos iniciales, as el mantenimiento del software aplica cada uno de los pasos precedentes del ciclo de vida a un programa existente en vez de a uno nuevo. Es de notar que no existen lmites definidos entre los diferentes pasos, y se supone que puede ser necesario en algunos casos regresar al paso anterior para afinar el diseo o el anlisis de requerimientos o el cdigo mismo del programa segn sea necesario. La metodologa empleada es la orientada por objetos, se har una breve presentacin de ella principalmente fundamentada en la metodologa expuesta por Maana[5].

Clases del Sistema

La primera tarea en el diseo de un sistema es encontrar las clases que lo componen. Para ello se realiza la especificacin de requerimientos del sistema, la cual debe incluir los objetivos de la aplicacin, las entradas esperadas y las respuestas deseadas. Se debe leer cuidadosamente sealando las frases nominales, con ello obtenemos una lista preliminar. En sta lista aparecern frases que incluyen clases obvias, frases que no tiene ningn sentido y frases sobre las cuales no se puede estar seguro. No todas las clases candidatas estarn en el diseo final y algunas posiblemente sern pasadas por alto en esta etapa. 130

Clases Concretas y Clases Abstractas

En la lista preliminar ya se diferencian los tipos de clases: aquellas que representan conceptos genricos y aquellas que representan conjuntos de uno o ms objetos concretos. Las primeras son llamadas superclases abstractas, y sirven para encapsular el comportamiento y los atributos comunes a un grupo de clases y no se espera crear objetos a partir de ellas. El segundo grupo de clases es conocido como clases concretas, ya que a partir de ellas se han de construir los objetos de la aplicacin, la mayora de estas clases sern descendientes de las abstractas (por esto son llamadas superclases).

Exploracin Inicial
El proceso de diseo orientado por objetos inicialmente es exploratorio. Se buscan las clases que se abstrae el conocimiento del sistema, siguiendo los siguientes pasos: 1. Encontrar las clases del sistema. 2. Determinar el conocimiento y comportamiento de los cuales cada clase es responsable. 3. Determinar las colaboraciones y responsabilidades entre los objetos. Con estos pasos se obtiene: Una lista de clases, una descripcin del conocimiento, las responsabilidades de cada clase y las colaboraciones entre ellas.

Anlisis Detallado
Con los datos encontrados en la exploracin, se inicia la etapa de proceso del diseo, en esta etapa se examina el comportamiento de cada clase y las relaciones de herencia con las otras clases del sistema, tratando de abstraer responsabilidades comunes que sern re-ubicadas en las superclases. Se analiza tambin el esquema de colaboracin entre las clases con el fin de distribuir el flujo de mensajes en forma equilibrada, para ello se responden preguntas como: Hay partes del sistema donde el trafico de mensajes es particularmente intenso?, hay clases que colaboran con todas las dems?, hay clases que no colaboran con ninguna otra?, de ser as, deben ser descartadas?. En las tarjetas donde se lleva la informacin de cada clase se agregan las clases y subclases correspondientes. Los pasos anteriores estn encaminados a producir un diseo inicial. Se identifican las clases del sistema, sus responsabilidades y las colaboraciones que garantizan los servicios requeridos. Se analizan despus las relaciones de herencia entre las clases y se identifican los contratos soportados, y se refina al diseo simplificando los patrones de comunicacin entre las clases. Se dividen las responsabilidades en grupos de clases llamados subsistemas y se mejora la forma en que estos encapsulan la funcionalidad global.

Registro de Clases
Cada clase identificada es registrada en una tarjeta donde se especifica su nombre y si es una clase concreta o abstracta, al respaldo de dicha tarjeta se describe el propsito de la clase dentro de la aplicacin. Estas tarjetas tambin servirn para registrar las responsabilidades de cada clase. 131

Responsabilidades
Es en ste momento del diseo en donde se define el propsito de la clase asignndole conocimiento y comportamiento, es decir, se determinan las responsabilidades de cada clase. Dichas responsabilidades incluyen los siguientes tpicos: 1. El conocimiento que la clase debe mantener. 2. Las acciones que la clase debe realizar. Las responsabilidades pueden ser identificadas, sealando en la especificacin de requerimientos los verbos que representen acciones que algn objeto del sistema deba realizar; es importante tener en cuenta la informacin manipulada por el sistema, ya que sta tambin representa responsabilidades de algn objeto. El propsito descrito en cada tarjeta de clase tambin nos indica responsabilidades, se debe saber que conocimiento y acciones estn implicadas en dicho propsito y que responsabilidades tiene la clase respecto al manejo de sus atributos. Las responsabilidades de una clase, y por tanto de todo objeto de esa clase, estan representadas en los servicios (acciones a realizar o informacin a retornar) que la clase provee para los contratos que soporta.

Colaboraciones
Las colaboraciones entre objetos son interacciones en un solo sentido, un objeto(cliente) solicita un servicio a otro objeto (servidor). Las formas validas en las cuales un objeto cliente puede interactuar con un objeto servidor estn especificadas en un contrato; ambos objetos deben cumplir con su parte del contrato. Es importante tener claro que cliente y servidor son roles y no atributos inherentes a la clase, de este modo un objeto puede asumir cualquiera de los roles en diferentes momentos.

Diagrama de Transicin de Estados

Una de las maneras ms tiles para obtener la informacin del sistema consiste en recorrer la aplicacin por diferentes caminos (walk-through), imaginando como es invocado cada servicio, viendo que otras responsabilidades estn implicadas en l y utilizando todos los servicios que pueda prestare el sistema. Para realizar esto se cuenta con una herramienta llamada diagrama de transicin de estados (DTE) de la aplicacin.

132

ANEXO B. GALIB

Visin General
GALib es una librera desarrollada en el MIT (Massachusetts Institute of Technology), que provee un conjunto de objetos para algoritmos genticos en C++. Aunque esta librera es bastante compleja, puede entenderse con el estudio de dos clases principales: Genoma y una Algoritmo Gentico. Cada instancia del Genoma representa una solucin sencilla al problema. El objeto Algoritmo gentico define como tendr lugar la evolucin. En el algoritmo gentico se usa una funcin objetivo (definida por el usuario) para determinar la supervivencia de los genomas. Esto usa los operadores (construidos dentro del genoma) y las estrategias de seleccin y reemplazamiento para generar nuevos individuos. Para resolver un problema usando algoritmos genticos se definen tres pasos: 1. Definir una representacin 2. Definir los operadores genticos 3. Definir la funcin objetivo GALib ayuda con los dos primeros tems al proveer varios ejemplos y piezas de los cuales se puede construir la representacin y operadores. En GALib, el genoma se trabaja a travs de la clase GAGenoma, la cual provee cuatro tipos de genomas (clases derivadas): - GAListGenome - GATreeGenome - GAArrayGenome - GABinaryStringGenome. Cada clase maneja como genoma una estructura de datos indicada por sus nombres. GALib trabaja con cuatro tipos bsicos de algoritmos genticos: Simple: (Descrito por Goldberg en su libro Genetic Algorithms in Search and Optimizations) Este algoritmo no usa superposicin de la poblacin (supervivencia de un individuo varias generaciones) y es opcionalmente elitista. Steady-State: Usa superposicin de la poblacin, en esta variacin se puede especificar cuanta poblacin debe ser reemplazada en cada generacin. Incremental: En este caso la poblacin consta de slo uno o dos hijos, este tipo permite la personalizacin del mtodo de reemplazamiento para definir como debe ser creada la nueva poblacin. 'deme': Este tipo involucra mltiples poblaciones en paralelo usando un algoritmo steadystate, cada generacin el algoritmo migra algunos individuos de cada poblacin a otras poblaciones. 133

Estos algoritmos difieren en la forma en que crean nuevos individuos y reemplazan los antiguos durante el curso de la evolucin. GALib trae ejemplos de derivacin de nuevas clases, adems tiene predefinidos tres operadores sobre los diferentes tipos de genomas: inicializacin, cruce y mutacin que se pueden personalizar para nuevos tipos de genomas obtenidos derivando la clase GAGenome. Adems cada genoma contiene una funcin objetivo (determinada por el usuario) y alguna forma de comparacin (llamada por algunos funcin de distancia). En general el desarrollo del algoritmo gentico es independiente del tipo de dato con que se trabaje el genoma. La librera refleja esta generalidad.

Objeto Poblacin
GALib maneja el objeto poblacin el cual es un contenedor de genomas. Cada objeto poblacin tiene su propio inicializador (por defecto es llamar al inicializador de cada sujeto de la poblacin) y evaluador (por defecto llama al evaluador de cada sujeto). Esto permite llevar una serie de estadsticas tales como: el mejor individuo, el promedio, y la desviacin estndar de cada poblacin, pero estos clculos no se llevan por defecto ya que pueden llegar a consumir bastantes recursos del sistema. El mtodo de seleccin (en el cual se escogen cuales individuos se reproducen con cuales) es tambin definido en el objeto poblacin. Cada objeto poblacin tiene un objeto de esquema de escalamiento asociado con l. El objeto de esquema de escalamiento convierte el puntaje objetivo de cada genoma en un puntaje de aptitud que el algoritmo gentico usa para la seleccin. Esto tambin oculta la informacin de aptitud para usarla posteriormente por el esquema de seleccin

Funcin Objetivo
Una de las grandes ventajas de los algoritmos genticos frente a otros mtodos es que slo necesitan una medida de qu tan bueno es un individuo comparado con otros. La funcin objetivo es esta medida, mientras el puntaje de aptitud determina la capacidad de un individuo para reproducirse (muchas veces no se usa funcin objetivo).

Operadores
Aqu se observan algunos ejemplos de los tipos de cruces y mutaciones que pueden ser efectuados usando GALib

134

Los operadores (que tambin pueden ser definidos por el usuario) no son funciones miembro de la clase genoma, ya que no se tiene que derivar una nueva clase para cambiar el comportamiento de uno de los tipos constructores de genoma, y adems el uso de funciones puntero en vez de funciones miembro permite cambiar los operadores en tiempo de ejecucin. Y ellos son ms rpidos que las funciones virtuales, por otro lado permiten que se cometan algunos errores por un inapropiado casting. Un hecho importante para destacar es que GALib usa su propio generador de nmeros aleatorios para garantizar la "calidad" de los mismos.

CLASES EN GALIB
En los siguientes diagramas se muestran las clases usadas en GALib y como son heredadas algunas de ellas. 135

GAGeneticAlgorithm
Esta es una clase abstracta que no puede ser instanciada. Cada algoritmo gentico tiene por defecto los operadores definidos en esta clase. Guarda estadsticas de la evolucin tales como el nmero de mutaciones, el nmero de cruces, el nmero de evaluaciones, el mejor, la media, el peor de cada generacin, y estadsticas de la poblacin inicial y de la actual. Aqu tambin se define la terminacin, una funcin miembro que especifica el criterio de parada del algoritmo. Se puede maximizar o minimizar por llamadas a las funciones apropiadas. Los parmetros tales como generaciones a completar, probabilidad de cruce o de mutacin pueden ser dados por un archivo, por la lnea de comandos o por medio de funciones miembro.

Descripcin de Funciones Miembro

convergence: Retorna la actual convergencia. La convergencia est definida como la razn entre el N-esimo mejor puntaje y el mejor puntaje actual. Crossover: Especifica el mtodo de cruce durante la evolucin, este puede cambiar durante el curso de una evolucin. Done: Retorna gaTrue si el criterio de terminacin ha sido alcanzado, retorna gaFalse en otro caso. Evolve: lnicializa el algoritmo gentico y evoluciona mientras el criterio de terminacin no se alcance. Flushfrecuency: Especifica que tan a menudo (numero de generaciones) se deben arrojar los valores a disco (si esta en cero no se escribe en disco). 136

Flushscores: Arroja los valores generacionales a disco. Generation: Arroja la actual generacin. Initialize: lnicializa el algoritmo gentico, si se le introduce un valor de semilla llama a GARandomSeed con este valor. NBestGenomes: Especifica cuantos mejores puntajes guardar. Nconvergence: Especifica el nmero de generaciones usadas para la prueba de convergencia. Ngenerations: Da el nmero de generaciones. Objectivedata: Pone los datos miembro objetivo en todos los individuos usados por el algoritmo gentico. Estos pueden cambiar durante la ejecucin. Objectivefunction: Coloca la funcin objetivo en todos los individuos. Parameters: Retorna una referencia a la lista de parmetros con sus valores actuales. parameters(GAParameterList&): Fija los parmetros para el algoritmo gentico. pconvergence: Da el porcentaje de convergencia. pcrossove: Pone la probabilidad de cruce. Pmutation: Coloca la probabilidad de mutacin. Population: Da la poblacin. Retorna una referencia a la actual poblacin. Populationsize: Fija el tamao de la poblacin. Este puede ser cambiado durante el curso de una evolucin. RecordDiversity: Especifica si es necesario calcular o no la diversidad. La diversidad requiere la comparacin de cada individuo con cada uno de los otros. Por defecto es gaFalse. RegisterDefauItParameters: Registra los parmetros por defecto, los parmetros a registrar son: flushfrequency, minimaxi, nBestGenomes, ngenerations, nconvergence, pconvergence, pcrossover, pmutation, populationsize, recorddiversity, scorefilename, scorefrequency y selectscores. scaling: Fija la escala del esquema, esta debe ser derivada de la clase GAScalingScheme. ScoreFiIename: Especifica el nombre del archivo en el cual los valores son almacenados. scorefrequency: Establece que tan a menudo los puntajes deben ser registrados. Selector: Coloca el esquema de seleccin para el algoritmo gentico. SelectScores: Determina cuales valores (estadsticos) se salvan en disco. Set: Fija un parmetro individual para el algoritmo gentico. Statistics: Retorna una referencia al objeto estadstica (mejor, peor, medio, desviacin estndar y diversidad de cada generacin). Step: Evoluciona el algoritmo gentico una generacin. Terminator: Da la funcin de terminacin. Userdata: Pone los datos para usar en el algoritmo gentico.

GAGenome
Esta es una clase virtual y no puede ser instanciada. Esta define un nmero de constantes y funciones prototipo especificas al genoma y sus clases derivadas. La dimensin es usada para especificar cual dimensin es referenciada en un genoma multi-dimensional. El mtodo clone especifica si clonar el genoma entero (un nuevo genoma con contenido igual al original debe ser creado) o slo los atributos del genoma (un nuevo genoma con caractersticas idnticas al original se crear) en ambos casos la llamada es responsable por borrar la cantidad de memoria por la funcin miembro clone. Los operadores genticos para genomas son funciones que toman genomas genricos como sus argumentos. Esto hace posible definir nuevos comportamientos para clases de genomas existentes sin derivar una nueva clase. 137

Descripcin de Funciones Miembro

clone: Este mtodo localiza espacio para un nuevo genoma mientras el mtodo copia usa el espacio para el genoma al cual pertenece. compare: Compara dos genomas. La comparacin puede ser basada en el genotipo (o fenotipo), si los genomas son idnticos retorna cero. comparator: Fija el mtodo de comparacin. copy: Se usa para copiar los contenidos de un genoma en otro existente, esta funcin es llamada por el operador de clase = y por el miembro clone. crossover: Cada clase genoma puede definir el mtodo de cruce preferido. Este mtodo asigna el mtodo de cruce preferido para una instancia del genoma. equal, notequal: Son especficos del genoma. evaldata: Pone el objeto usado para almacenar los datos de evaluacin del genoma especifico. evaluate: Invoca la funcin de evaluacin del genoma. evaluator: Especifica la funcin de evaluacin del genoma. geneticalgorithm: Esta funcin miembro retorna un puntero al algoritmo gentico "propietario" del genoma. initialize: Llama la funcin de iniciacin para el genoma. initializer: Carga el mtodo de iniciacin. mutate: Llama el mtodo de mutacin para el genoma. mutator: Fija el mtodo de mutacin. nevals: Retorna el nmero de evaluaciones de la funcin objetivo desde que el genoma fue inicializado. operator == , operator != , operator <<, operator >>: Estos mtodos llaman la funcin miembro virtual asociada. Ellos pueden ser usados por algn genoma genrico. read: Llena el genoma con los datos ledos desde el flujo especificado. sexual, asexual: Retorna un puntero al mtodo de cruce preferido por este genoma. score: Retorna el puntaje objetivo del genoma usando la funcin objetivo asignada al genoma. userdata: Cada genoma contiene un puntero genrico a datos especficos del usuario, esta funcin miembro retorna este puntero. write: Enva los contenidos del genoma al flujo especificado.

GAStatics
El objeto estadsticas contiene informacin sobre el actual estado del objeto algoritmo gentico. Cada algoritmo gentico contiene un objeto estadsticas.

Descripcin de Funciones Miembro

bestever: Retorna el puntaje del mejor individuo encontrado. bestindividual: Esta funcin retorna la referencia del mejor individuo encontrado por el algoritmo gentico. bestpopulation: Devuelve la referencia a la poblacin que contiene el mejor individuo encontrado por el algoritmo gentico. convergence: Retorna la actual convergencia. La convergencia est definida como la razn entre el N-esimo mejor puntaje y el mejor puntaje actual. crossovers: Retorna el nmero de cruces que han ocurrido desde la iniciacin. 138

current: Devuelve el puntaje especifico de la poblacin actual. flushfrecuency. Especifica que tan a menudo (nmero de generaciones) se deben arrojar los valores a disco (si est en cero no se escribe en disco). flushscores: Arroja los valores generacionales a disco. generation: Da el nmero de la generacin actual. inicial: Indica el puntaje de la poblacin inicial. mutations : Muestra el nmero de mutaciones que han ocurrido desde la iniciacin nBestGenomes: Especifica cuantos mejores puntajes guardar nconvergence: Especifica el nmero de generaciones usadas para la prueba de convergencia. offline: Devuelve el promedio de los mejores puntajes de la generacin. online: Otorga el promedio de todos los puntajes. recordDiversity: Esta opcin booleana determina si la diversidad de una poblacin debe ser calculada para cada generacin. Por defecto esta opcin es falsa. replacements : Indica el nmero de sustituciones que han ocurrido desde el inicio. reset: Elimina el contenido del objeto estadsticas usando el contenido de la poblacin especifica. scorefilename: Fija el nombre del archivo en el cual se guardarn los puntajes de salida, por defecto este nombre es "generations.dat' scorefrequency: Determina la frecuencia con la cual el puntaje de la generacin debe ser registrado, la opcin por defecto depende del tipo de algoritmo que se este usando. scores: Imprime los puntajes de la generacin en el flujo especificado selectscores : Esta funcin se usa para especificar cuales puntajes deben ser salvados en disco (media, mximo, mnimo, desviacin estndar, diversidad). update: Actualiza los contenidos del objeto estadsticas reflejando el estado de la poblacin especificada. worstEver: Retorna el puntaje del peor individuo encontrado. bestever: Devuelve el puntaje del mejor individuo encontrado.

Funciones para el Manejo de Nmeros Aleatorios

GAlib incluye las siguientes funciones para la generacin de nmeros aleatorios
void GARandomSeed(unsigned s = 0) int GARandomint() int GARandomint(int low, int high) double GARandomDouble() double GARandomDouble(double low, double high) float GARandomFloat() float GARandomFloat(float low, float high) int GARandomBit() GABoolean GAFlipCoin(float p) int GAGaussianint(int stddev) float GAGaussianFloat(float stddev) double GAGaussianDouble(double stddev) double GAUnitGaussiano

Si se llama sin argumentos la funcin GARandomSeed usa la hora actual multiplicado por el identificador del proceso como semilla para un generador de nmeros pseudo - aleatorios si se llama con algn argumento este es usado como semilla del generador. Una vez la semilla est especificada una llamada a GARandomSeed con el mismo valor no tiene efecto, pero una llamada con otro argumento reinicializa el generador de nmeros aleatorios usando el nuevo valor. 139

GAFlipCoin retorna un valor booleano basado en un sesgo dado. La funcin GARandomBit es la ms eficiente forma de nos sesgar los resultados. La funcin Gaussiana retorna a un nmero que sigue la distribucin Gaussiana con una desviacin especificada. La funcin GAUnitGaussian retorna a nmero que sigue una distribucin Gauss normalizada (media 0 y varianza 1). GAlib usa un solo generador de nmeros aleatorios para toda la librera que puede ser cambiado cuando se compila la librera

Manejo de Errores
Si una funcin retorna un estado de error se despliega un mensaje de error llamada gaErrMsg. Por defecto, el mensaje de error es mandado inmediatamente al flujo de errores, aunque se puede desactivar la impresin de errores pasando gaFalse a la funcin GAReportErrors. Si se quiere redireccionar el mensaje de error a un flujo diferente se asigna el nuevo flujo usando la funcin GASetErrorStream.

140

ANEXO C. XILINX FOUNDATION F1.5

XILINX Foundation es un software especializado de ALDEC INC, que cumple con las siguientes tareas: Permitir el diseo de circuitos programables Realizar simulacin funcional y cronomtrica del diseo Implementar el diseo Programar un dispositivo En este captulo se resean las caractersticas bsicas de XILINX FOUNDATION que fueron tiles para la prueba de los circuitos encontrados por medio del programa SimEHDL presentado en esta investigacin. Debe notarse que este software (Foundation Series) es bastante complejo, y brinda al ingeniero una gran cantidad de soluciones en el momento de utilizar circuitos lgicos programables. XILINX FOUNDATION est compuesto por diversos mdulos, que no sern detallados en este informe. Simplemente se listan a continuacin los pasos bsicos para la programacin de un dispositivo lgico desde la etapa de diseo hasta la carga fsica de la configuracin en le circuito lgico programable.

DISEO DEL CIRCUITO

El diseo del circuito puede hacerse por medio de diagramas, mquinas de estado finito, o lenguajes de descripcin de hardware tales como VHDL o VERILOG. En el proyecto que se realiza, el enfoque utilizado es el esquemtico (diseo grfico de la red del circuito), donde se puede insertar un bloque lgico (caja negra) que corresponde a una macro creada en lenguaje VHDL. XILIX Foundation cuenta con un editor de cdigo VHDL que permite adems del ingreso del diseo por medio de este lenguaje, la compilacin de sintaxis, la sntesis del circuito y la creacin de una macro para ser utilizada dentro de un proyecto esquemtico.

141

Una vez se ha creado una macro puede insertarse dentro del diseo normal de un circuito. As,. Un bloque lgico creado en VHDL que funciona como un sumador de 3 bits puede hacer parte de un sistema ms complejo creado por medio del enfoque esquemtico.

142

SIMULACION
Cuando se tiene el diseo del circuito, se procede a la fase de simulacin. Se usa la simulacin funcional, para estudiar el comportamiento de las seales de salida de acuerdo nicamente a las combinaciones de las seales de entrada (para circuitos combinatorios). Una forma de realizar simulacin dentro del entorno XILINX FOUNDATION, consiste en seleccionar todas las seales que desean estudiarse (bien sean de entrada, salida o entrada/salida). Entonces, el paquete permite asociar diversos tipos de estmulos a las seales de entradas, tales como: Entradas de Usuario Pulsos de Reloj Secuencias La siguiente grfica refleja un instante en la simulacin de un circuito sumador de 3 bits:

IMPLEMENTACION
Despus de haber comprobado el funcionamiento del circuito en el ambiente simulador, el usuario puede pasar a una fase de implementacin. All, se generan los archivos que son capaces de programar dispositivos tales como FPGAs o CPLDs. La siguiente figura muestra una pantalla que permite al usuario indicar el tipo de dispositivo que desea programar:

143

VERIFICACION
Luego, se procede a una verificacin especfica de diversos problemas que pueden afectar el comportamiento del circuito. Por ejemplo, puede observarse el comportamiento en los procesos denominados: placing, mapping y routing, donde se implementa el diseo en un archivo bitstream capaz de programar el circuito lgico.

PROGRAMACION
Por ltimo, el usuario puede cargar la configuracin recin creada en el dispositivo fsico utilizando un puerto de intercambio de datos, y una tarjeta compatible.

144