SIMULADOR PARA LA CONSTRUCCIÓN DE CIRCUITOS COMBINACIONALES POR MEDIO DE ALGORITMOS GENÉTICOS CON

APLICACIÓN A UN SUMADOR DE 3 BITS, ORIENTADO A DISPOSITIVOS REPROGRAMABLES

German Flórez Larrahondo Miguel Eduardo Torres Moreno

UNIVERSIDAD NACIONAL DE COLOMBIA FACULTAD DE INGENIERIA

DEPARTAMENTO DE INGENIERIA DE SISTEMAS SANTAFE DE BOGOTA

1999

SIMULADOR PARA LA CONSTRUCCIÓN DE CIRCUITOS COMBINACIONALES POR MEDIO DE ALGORITMOS GENÉTICOS CON

APLICACIÓN A UN SUMADOR DE 3 BITS, ORIENTADO A DISPOSITIVOS REPROGRAMABLES

GERMAN FLÓREZ LARRAHONDO MIGUEL EDUARDO TORRES MORENO

Tesis entregada como parte de los requisitos para optar al título de Ingeniero de Sistemas

Director JORGE EDUARDO ORTIZ TRIVIÑO

Ingeniero de Sistemas

Codirector FABIO GONZALEZ OSORIO

UNIVERSIDAD NACIONAL DE COLOMBIA FACULTAD DE INGENIERIA

DEPARTAMENTO DE INGENIERIA DE SISTEMAS SANTAFE DE BOGOTA

1999

Calificación de aceptación Director Codirector Jurado Jurado

Santafé de Bogotá, Agosto de 1999

COMENTARIOS

TABLA DE CONTENIDO

INTRODUCCION 9

1. MARCO TEORICO 10

1.1. HARDWARE EVOLUTIVO 10

1.1.1. INTRODUCCIÓN 10

1.1.2. EVOLUCIÓN 10

1.1.2.1. Evolución artificial 11

1.1.3. DEFINICIÓN DE HARDWARE EVOLUTIVO 11

1.1.4. ARQUITECTURA DEL HARDWARE EVOLUTIVO 12

1.1.5. DISEÑO EVOLUTIVO 13

1.1.5.1.Ventajas del Diseño Evolutivo 13

1.1.6. HARDWARE EVOLUTIVO: EN PERSPECTIVA 13

1.2. INTRODUCCION A LOS ALGORITMOS GENETICOS 14

1.2.1. GENERALIDADES 14

1.2.2. DESCRIPCIÓN DE UN ALGORITMO GENÉTICO SIMPLE 15

1.2.2.1. Estructuras y Datos 15

1.2.2.2. Codificación Binaria 16

1.2.2.3. Codificación con Caracteres y Valores Reales 16

1.2.2.4. Estructura en Arbol 16

1.2.2.5. Algoritmo Genético Simple General 17

1.2.2.5.1. Obtención de la Primera Generación 17

1.2.2.5.2. Evaluación de las Cadenas 17

1.2.2.5.3. Selección de Estructuras 18

1.2.2.5.4. Cruzamiento 18

1.2.2.5.5. Mutación de Cadenas 19

1.2.3. OTRAS CARACTERÍSTICAS 19

1.2.3.1. Métodos de Selección 19

1.2.3.1.1. Selección Proporcional a la Aptitud con Juego de Ruleta 20

1.2.3.1.2. Escalización Sigma 20

1.2.3.1.3. Elitismo 20

1.2.3.1.4. Selección por Clasificación 20

1.2.3.1.5. Selección por Torneo 21

1.2.3.2. Operadores Genéticos 21

1.2.3.2.1. Cruce 21

1.2.3.2.2. Mutación 22

1.3. PROGRAMACION GENETICA 22

1.3.1. INTRODUCCIÓN 22

1.3.2. SELECCIÓN DEL LENGUAJE DE PROGRAMACIÓN 23

1.3.2.1 Por Que LISP 25

1.3.3. CARACTERÍSTICAS DE LA PROGRAMACIÓN GENÉTICA 26

1.3.3.1. Las Estructuras que Sufren Adaptación 27

1.3.3.1.1. Cierre 29

1.3.3.1.2. Suficiencia 29

1.3.3.2. Las Estructuras Iniciales 29

1.3.3.3. La Aptitud 31

1.3.3.4.Operaciones para la Modificación de Estructuras 34

1.3.3.4.1. Reproducción 34

1.3.3.4.2. Cruce (Recombinación) 34

1.3.3.5. El Estado del Sistema 37

1.3.3.6. Designación del Resultado 37

1.3.3.7. Terminación 37

1.3.3.8. Parámetros de Control 38

1.3.4. FUNCIONES PREDEFINIDAS 38

1.3.5. ALGORITMO DE DEJOUNG 38

1.4. CIRCUITOS LOGICOS COMBINATORIOS 39

1.4.1. DEFINICIÓN 39

1.4.2. LÓGICA BINARIA 40

1.4.2.1. Adición Lógica 40

1.4.2.2. Multiplicación Lógica 41

1.4.2.3. Inversión Lógica 41

1.4.3. OTRAS COMPUERTAS LÓGICAS 42

1.4.3.1. Compuerta Or Exclusiva 42

1.4.3.2. Compuerta Nand 43

1.4.3.3. Compuerta Nor 44

1.4.3.4. Importancia de las Compuertas Nand y Nor 44

1.4.4. DISEÑO ANALÍTICO DE CIRCUITOS LÓGICOS COMBINATORIOS 45 2

1.4.4.1. Simplificación de Funciones 46

1.4.4.2. Mapas De Karnaugh 46

1.4.4.3. Teoremas de Boole y Morgan 47

1.4.5. EJEMPLOS 48

1.4.5.1. Sumadores 48

1.4.5.1.1. Sumador Medio 48

1.4.5.1.2. Sumador Total 48

1.4.5.2. Sustractores 50

1.4.5.2.1. Sustractor Medio 50

1.4.5.2.2. Sustractor Completo 50

1.4.5.3. Relación Entre Sumadores y Sustractores 51

1.4.5.4. Generación y Comprobación de Paridad 51

1.4.5.5. Decodificadores 52

1.5. LENGUAJE VHDL 53

1.5.1. INTRODUCCIÓN A VHDL 53

1.5.1.1. Breve Reseña Histórica 53

1.5.1.2. Características 53

1.5.1.3. Ventajas 54

1.5.1.4. Desventajas 55

1.5.2. MÉTODOS DE DISEÑO 55

1.5.2.1. Diseño Estructural 55

1.5.2.2. Diseño por Flujo de Datos 56

1.5.2.3. Diseño de Comportamiento 56

1.5.3. APROXIMACIÓN AL DISEÑO ESTRUCTURAL 56

1.5.3.1. Definición de Bloques 57

1.5.3.2. Entidad 57

1.5.3.3 Tipos De Señales 58

1.5.3.4. Arquitectura 59

1.5.3.4.1. Operadores Lógicos 60

1.5.3.4.2. Sentencia With-Select 60

1.5.3.5. Componentes e Instancias 61

1.6. FIELD PROGRAMMABLE GATE ARRAY: FPGA 64

1.6.1. CONCEPTOS BÁSICOS 64

1.6.2. FPGA SERIE XC4000 65

1.6.2.1. Descripción 66

1.6.2.2. Componentes Básicos 66 3

1.6.2.2.1 Bloques Lógicos Configurables 66

1.6.2.2.2. Bloques de Entrada/Salida 67

1.6.2.2.3. Buffers de Tres Estados 68

1.6.2.2.4. Interconexiones 68

1.6.2.3. Reconfiguración del FPGA 68

1.6.2.3.1. Reconfiguración Estática 69

1.6.2.3.2. Reconfiguración Dinámica 69

1.6.2.4. Programación del FPGA 69

1.6.2.4.1. Captura del Diseño 69

1.6.2.4.2. Implementación del Diseño 70

1.6.2.4.3. Verificación del Diseño 71

1.6.2.4.4. Configuración 71

2. ANALISIS Y DISEÑO DEL PROBLEMA 72

2.1. METODOLOGIA 72

2.2. ANALISIS DEL PROBLEMA PARA EL DESARROLLO DEL MODELO 72

2.2.1. ANÁLISIS PRELIMINAR 72

2.2.2. ESPECIFICACIÓN DE REQUERIMIENTOS 72

2.2.2.1 Entradas 73

2.2.2.2. Algoritmo de Programación Genética 73

2.2.2.3. Salidas 74

2.3. DISEÑO DE LA APLICACION. 74

2.3.1. DESCOMPOSICIÓN FUNCIONAL 74

2.3.2. FLUJO DE DATOS 75

2.3.3. DEFINICIÓN DE LA ESTRUCTURA LISP (ARBOLES) Y CONSIDERACIONES INICIALES DEL PROBLEMA

76

2.3.3.1. La Raíz 76

2.3.3.2. Las Funciones 76

2.3.3.3. Las Terminales 77

2.3.3.4. Ejemplo 77

2.3.4. CLASES 77

2.3.4.1. Lista Preliminar de Clases 77

2.3.4.2. Lista Final de Clases 79

2.3.4.3. Registro De Clases 79

2.3.4.4. Diagrama de Colaboraciones Entre Objetos 85 4

2.3.5. DIAGRAMA DE TRANSICIÓN DE ESTADOS 85

2.3.5.1. Descripción de las Transiciones 86

2.4. IMPLEMENTACION 86

2.4.1. HERRAMIENTAS DE DESARROLLO 86

2.4.2. HERRAMIENTAS ADICIONALES 87

2.4.2.1. GALIB 87

2.4.2.2. Xilinx Foundation Software 87

2.4.2.3. RANDOMLIB 87

2.4.3. MODULO TABLAS DE VERDAD 87

2.4.3.1. Especificación de Requerimientos 87

2.4.3.2. Clases 88

2.4.3.2.1. Lista Preliminar de Clases 88

2.4.3.2.2. Lista Final de Clases 88

2.4.3.2.3. Registro de Clases 88

2.4.3.2.4. Diagrama de Colaboraciones Entre Objetos 91

2.4.4. DIAGRAMA DE TRANSICIÓN DE ESTADOS 91

2.4.4.1. Descripción de las Transiciones 91

3. PRUEBAS Y RESULTADOS 93

3.1. SUMADOR COMPLETO DE 3 BITS 93

3.1.1. EJEMPLO RESULTANTE CON LA TODAS LAS FUNCIONES BÁSICAS 95

3.1.2. EJEMPLO RESULTANTE SIN EL USO DE LA COMPUERTA XOR 97

3.1.3. RESULTADOS CON FUNCIONES DEFINIDAS POR EL USUARIO 100

3.1.3.1. Ejemplo Resultante Con Funciones de Usuario 100

3.2. MULTIPLEXOR DE 2 ENTRADAS DE DOS BITS 104

3.2.1. EJEMPLO RESULTANTE 105

3.2.2.EJEMPLO CON FUNCIONES DE USUARIO 107

LOGROS 115

CONCLUSIONES Y RECOMENDACIONES 117

BIBLIOGRAFIA 118

5

MANUAL DEL USUARIO 120

HOJA TECNICA 129

ANEXOS 130

ANEXO A. METODOLOGIA DE ANALISIS Y DISEÑO 130

ANEXO B. GALIB 133

ANEXO C. XILINX FOUNDATION F1.5 141

6

INDICE DE ILUSTRACIONES Figura 1 La S-expresión 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-expresión (OR (AND(NOT D0) (NOT D1)) (AND D0 D1)) ..................28

Figura 3 La generación de un árbol aleatorio podría empezar con etiquetar la raíz del árbol con la función +.......30

Figura 4 La generación de un árbol aleatorio podría continuar con etiquetar un punto interior con la función *. ...30

Figura 5 La generación de un árbol aleatorio podría 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 lógico combinacional..............................................................................................39

Figura 10 Esquema de un circuito lógico 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 lógico 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 Lógico..................................................................................................................67

Figura 22 Estructura de un Bloque E-S. ......................................................................................................................68

Figura 23 Captura del diseño en FOUNDATION de XILINX. ....................................................................................70

Figura 24 código XNF de un diseño capturado en FOUNDATION SERIES de Xilinx................................................71

Figura 25 Diagrama de Flujo de datos de la Aplicación.............................................................................................73

Figura 26 Diagrama de Representación Funcional de la Aplicación..........................................................................74

Figura 27 Descomposición por módulos de la aplicación. ..........................................................................................76

Figura 28 Representación lógica y de árbol de un circuito sumador completo de 2 bits, cuya representación LISP

corresponde a: CONCAT((XOR(A B))(AND(A B))).....................................................................................................77

Figura 29 Diagrama de Colaboraciones Entre Objetos. .............................................................................................85

Figura 30 Diagrama de Transición de Estados. ..........................................................................................................86

Figura 31 Colaboraciones entre objetos del módulo Editor de tablas.........................................................................91

Figura 32 Diagrama de Transición de Estados. ..........................................................................................................91

7

INDICE DE TABLAS Tabla 1 Combinaciones Posibles .................................................................................................................................39

Tabla 2 Valores Booleanos ..........................................................................................................................................40

Tabla 3 Tabla de verdad de la adición lógica..............................................................................................................40

Tabla 4 Tabla de verdad de la multiplicación lógica...................................................................................................41

Tabla 5 Tabla de verdad de la inversión lógica ...........................................................................................................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 comprobación de paridad impar................................................................52

Tabla 20 Tabla de verdad de un circuito decodificador de línea de 2 a 4 ...................................................................53

Tabla 21 Elementos básicos de la declaración de una entidad....................................................................................58

Tabla 22 Valores del tipo STD_LOGIC .......................................................................................................................58

Tabla 23 Elementos básicos de la declaración 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 función XOR............................................................................96

Tabla 30 Resumen del comportamiento utilizando funciones de usuario ..................................................................100

Tabla 31 Resumen del comportamiento para el multiplexor de 2 entradas ...............................................................104

8

INTRODUCCION Actualmente muchos problemas en aprendizaje de máquinas, inteligencia artificial, y procesamiento simbólico pueden resolverse con una búsqueda en el espacio de programas, para encontrar la solución que más se ajuste a las necesidades planteadas por el problema. Es entonces cuando aparece la programación genética, método que brinda una forma eficiente para realizar esta búsqueda y obtener una solución (aproximada) al problema dado, por medio de la coexistencia de una población de individuos (programas) interactuando entre sí por el principio Darviniano de la supervivencia del individuo más apto. De ella misma surge entonces el Hardware Evolutivo, proceso de adaptación 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 interacción con el ambiente. En el caso particular de esta investigación el problema planteado consiste en buscar por medio de la programación genética la generación de un programa VHDL (Very High Speed Integrated Circuits Hardware Description Lenguage, que significa, Lenguaje de Descripción de Hardware para Circuitos Integrados de Alta Velocidad), que contenga el comportamiento de un circuito lógico combinatorio, buscado por el usuario. SimEHDL es uno de los primeros trabajos realizados en la Universidad Nacional de Colombia, que aplica los conceptos de programación genética 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 capítulo se exponen las bases teóricas que soportaron el desarrollo del proyecto. Comprende la descripción y funcionamiento un algoritmo genético y su especialización en la programación genética, conceptos básicos sobre circuitos lógicos combinatorios, lenguaje VHDL, y dispositivos reprogramables FPGA. En el segundo capítulo se describe el proceso de análisis, diseño e implementación del simulador, el cual fue llevado a cabo siguiendo las etapas descritas por la metodología tradicional del ciclo de vida del software, además se enumeran las herramientas utilizadas durante el proceso de implementación. En el último capítulo se describen pruebas realizadas al simulador con diferentes circuitos combinatorios y sus resultados. En la parte final de este capítulo se detallan las conclusiones y logros obtenidos luego de la elaboración de la presente investigación.

9

1. MARCO TEORICO

1.1. HARDWARE EVOLUTIVO 1.1.1. Introducción Los organismos vivientes son sistemas complejos que exhiben un rango de características especiales tales como evolución, adaptación, y tolerancia a los fallos. Dichos rasgos han mostrado ser de difícil comprensión usando metodologías de ingeniería tradicionales. Sin embargo, desde hace algún tiempo se ha introducido en la ingeniería un conjunto de conceptos basados en procesos de seres vivos, tales como las redes neuronales y la evolución de individuos. Estos sistemas que evolucionan se caracterizan por un programa genético (genoma), que define el desarrollo del ser o individuo, su funcionamiento y extinción. 1.1.2. Evolución La evolución es un proceso incesante en el que entidades biológicas se adaptan en un entorno variable. Es un procedimiento que ocurre gradualmente tras centenares de miles de generaciones para crear especies que se adaptan específicamente al ambiente en cualquier momento en particular. Para explicar la evolución, se deben estudiar algunos aspectos biológicos simples. Cada ser viviente en la tierra posee una cadena de ADN que le identifica(genotipo). El genotipo describe de una manera compleja (a través del uso de interacciones químicas) cómo construir una entidad biológica específica (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 multiplicación de los organismos vivientes se basa en la reproducción del programa(ADN), sujeto a una proporción de error sumamente baja a nivel individual, para asegurar que la identidad de la descendencia permanezca prácticamente inalterada. La mutación (reproducción asexual) junto con la recombinación (reproducción sexual) da lugar a la emergencia de nuevos organismos. Los mecanismos de la filogenética (evolución de las especies) son fundamentalmente no-deterministicos, la rata de mutación y la proporción de recombinación brindan una fuente mayor de diversidad. Esta diversidad es indispensable para la supervivencia de las especies vivientes, para su adaptación continua a un ambiente cambiante, y para la aparición de nuevas especies.

10

Así se tiene que la filogénesis (Evolución) es la que mejor describe lo que se conoce como Hardware Evolutivo, siendo este referenciado intuitivamente como evolución artificial, lo que a su vez nos lleva a los algoritmos genéticos, programación evolutiva, etc. Inicialmente es necesario crear una medida de aptitud para cada individuo: Un individuo nacerá sin defectos, vivirá hasta la edad de reproducción 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 más a menudo que otros individuos, este gen será mas útil y podrá ser llevado a una próxima generación. Si un gen es malo se elimina el individuo antes que este puede reproducirse, dicho gen no continuará en la próxima generación. Así es como ocurre la evolución ciertos genes nos permiten vivir y por consiguiente aumentar las oportunidades de reproducción. Así los genes avanzan a través de las generaciones logrando solo la supervivencia de los mejores o más aptos.

1.1.2.1. Evolución artificial La Evolución artificial es el proceso de aplicar la evolución a sistemas artificiales. La base de estos sistemas es la creación artificial de ADN y un método para combinarlo. El trabajo que debe hacerse es la traducción del genotipo al fenotipo y la medición de la aptitud de este último dentro del ambiente. Un primer método fue descrito por J. Holland en su libro, "La Adaptación en sistemas naturales y artificiales", y se le llamó Algoritmos Genéticos. 1.1.3. Definición de Hardware Evolutivo Hardware Evolutivo (Evolvable Hardware, conocido con las siglas EHW) es la aplicación de estrategias biológicas sobre dispositivos electrónicos. La idea llegó después que un desarrollador de algoritmos genéticos hablo sobre la existencia de dispositivos electrónicos los cuales tienen la capacidad de ser programados usando cadenas binarias. Esta idea dio pie a la investigación específica en dos áreas diferentes: EHW Extrínseco

Un algoritmo evolutivo crea una configuración para el hardware cuya aptitud se efectúa sobre una simulación del Hardware EHW Intrínseco

La aptitud del individuo es evaluada transmitiendo la configuración al hardware y evaluando el sistema in-situ. En el EHW, la adaptación equivale a la modificación directa de las estructuras del hardware acorde a las influencias recibidas del entorno. Esto brinda ventajas como la adaptación en tiempo real, la flexibilidad y tolerancia a fallos. 11

Se han visto progresos significativos en investigación sobre hardware basado en maquinas como Perceptrón, WISARD, y ALNs (redes lógicas adaptativas). El hardware evolutivo, sin embargo, a estado limitado, en el sentido que en la mayoría de experimentos realizados hasta ahora la adaptación que se lleva a cabo es off-line o extrínseca. Sin embargo, las máquinas adaptativas ideales deben poder cambiar su estructura física mientras son usadas en tiempo real (es decir con adaptación on-line o intrínseca). Con tal adaptación, se pueden evitar funcionamientos defectuosos del hardware en sistemas de computación usados en circunstancias extraordinarias como en el espacio y el fondo del mar. La distinción más clara entre el hardware convencional (CHW) y EHW radica en que el diseño de CHW no puede “iniciar” hasta que se den las característica técnicas del hardware al diseñador. Por otro lado, el EHW puede usarse en situaciones donde nadie sabe la especificación del hardware deseada previamente. El EHW puede reconfigurar su estructura a través de aprendizaje genético. 1.1.4. Arquitectura del Hardware evolutivo El proceso de adaptación es una combinación de aprendizaje genético con aprendizaje reforzado. A continuación 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 configuración dada externamente (realmente un conjunto de bits). Dicha configuración es capaz de alterar físicamente el dispositivo lógico 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 genético, el EHW puede seleccionar por si mismo la arquitectura lógica del dispositivo que da mayor rendimiento con respecto a su entorno. El esquema de aprendizaje genético es paralelo a los algoritmos genéticos. Los GAs operan sobre una población 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 generación de individuos que incorporan algunas características de sus antecesores. Esta nueva generación 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 basándose en la retribución a continuación de la respuesta que exhibe el sistema (retroalimentación). Esta retribución es relacionada a la calidad de la respuesta y podría tardarse. La finalidad es maximizar o minimizar una retribución negativa. No hay ningún maestro o supervisor involucrado en este esquema de aprendizaje 12

1.1.5. Diseño Evolutivo Para el caso en el cual el EHW es aplicado como alternativa para el diseño de circuitos se presentan dos faces: 1. Diseño Evolutivo: Proceso en el cual por medio de técnicas evolutivas, se busca una

arquitectura que represente un circuito determinado. 2. Ejecución: Consiste en la implementación física de la arquitectura encontrada. De lo anterior se desprende entonces una clasificación dependiente de la representación del cromosoma [1]: 1. Representación Directa: El cromosoma configura una arquitectura en bits de diferentes

componentes hardware o de compuertas lógicas. 2. Representación Indirecta: El cromosoma es una representación 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 Diseño Evolutivo En esencia la aproximación convencional especifica como diseñar e implementar un circuito, mientras la aproximación evolutiva busca definir solamente el comportamiento del circuito. Las ventajas del método evolutivo, respecto al convencional son: Evalúa un mayor rango de alternativas de aquellas consideradas por el ser humano. El diseño 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 aproximación evolutiva puede trabajar con diferentes grados de restricción y

requerimientos. Si existe cualquier conocimiento anterior este puede ser aplicado para mejorar la eficiencia

del diseño. Es importante notar que los experimentos de EHW conducidos hasta el momento han sido a pequeña escala (es decir, que el EHW es pequeño en componentes en comparación a los circuitos diseñados por el método tradicional), y aun con esa pequeña 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 sería de la siguiente forma:

13

Inicialmente se tiene lo que es en esencia el diseño evolutivo, donde todas las operaciones se llevan a cabo en software, con la posibilidad de cargar la solución en un circuito real. Seguidamente, se encuentran trabajos en los que un circuito real es usado durante el proceso

evolutivo, y la mayoría de las operaciones se realizan extrínsecamente, 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 genéticas

(selección, cruce, mutación, y calculo de aptitud) se llevan a cabo en hardware (intrínseco). El mayor elemento perdido en esta parte se refiere al hecho de que la evolución se lleva a cabo como un sistema cerrado, es decir, hay una meta predefinida y ningún entorno dinámico del cual tomar información. La última y más importante fase es en la cual una población de entidades hardware

evoluciona en un entorno abierto. Ésta última fase para muchos investigadores es considerada como el verdadero hardware evolutivo. Una aplicación natural en estos sistemas es el área de los robots autónomos, que involucra maquinas capaces de operar en entornos desconocidos sin la intervención humana.

1.2. INTRODUCCION A LOS ALGORITMOS GENETICOS 1.2.1. Generalidades Fueron inventados por John Holland (1975), cuya inspiración fue el proceso evolutivo presente en la naturaleza. Así, un Algoritmo Genético es una técnica de optimización basada en la selección natural (cruce, mutación y selección natural de individuos). Un Algoritmo Genético (GA) es un procedimiento interactivo que consiste en una población de tamaño constante de individuos, cada uno representado por una cadena finita de símbolos codificando una posible solución en algún espacio del problema. Este espacio también conocido como espacio de búsqueda, comprende todas las posibles soluciones del problema a mano. El alfabeto de símbolos es generalmente binario, gracias a su generalización y a otras propiedades matemáticas. El GA “estándar” trabaja de la siguiente manera: Inicialmente una población de individuos es generada aleatoria o heurísticamente. En cada paso evolutivo llamado generación, los individuos en la población actual son decodificados y evaluados de acuerdo a algunos criterios predefinidos de selección, referidos como aptitud. Para formar los individuos de la siguiente generación, los individuos son seleccionados con una probabilidad proporcional a su aptitud, esto asegura que el número de veces que un individuo es seleccionado es proporcional a su actuación dentro de la población; esto significa que a mayor aptitud tenga un individuo, mayor será el chance de que este se reproduzca. La selección no puede en si introducir nuevos individuos a la población; estos son generados por medio de operadores genéticos, de los cuales los más usados son: cruce y mutación. Combinando la supervivencia de los mejores individuos dentro de un conjunto, los más aptos, con un intercambio de información estructurado y aleatorio, que imita los procesos de evolución biológica.

14

Los Algoritmos Genéticos son algoritmos evolutivos ya que explotan eficientemente la información histórica, permitiendo especular sobre nuevos puntos de búsqueda, dentro del espacio de soluciones, esperando un mejor comportamiento a través de su evolución. El objetivo de los Algoritmos Genéticos es doble: (1) explicar rigurosamente los procesos adaptativos de los sistemas naturales, y (2) diseñar software de sistemas artificiales, que contengan los mecanismos más importantes de los sistemas naturales. El ingeniero, diseñador de sistemas artificiales, solo puede maravillarse ante la robustez, la eficiencia, y la flexibilidad de los sistemas biológicos. Características como autoreparación, autoguía, y reproducción, son la regla de los sistemas biológicos, características de las que generalmente carecen los sistemas artificiales más sofisticados. Así se llega a una conclusión interesante: donde se requiera un comportamiento robusto, la naturaleza lo ha hecho mejor. Los secretos de la adaptación y la supervivencia se aprenden mejor del estudio cuidadoso del ejemplo biológico. 1.2.2. Descripción de un Algoritmo Genético Simple Los mecanismos de un Algoritmo Genético Simple, A.G.S., son sorprendentemente sencillos, lo más complejo que incluyen son la copia de cadenas y el intercambio parcial de cadenas. A continuación se presenta, la implementación de un A.G.S. Un Algoritmo Genético Simple, que da buenos resultados en muchos problemas prácticos, se compone de tres operadores: Selección. Cruce. Mutación.

Primero se estudiará un algoritmo genérico 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 parámetros de un A.G.S., como son: • Número de generaciones (M). • Tamaño de la población (K). • Estructura del cromosoma, así como lo relacionado a él como son: su decodificación (su

valor), su aptitud, y el porcentaje que su aptitud aporta a la aptitud total de la población, además de su longitud en bits (L).

El último punto es en especial importante pues de él depende el éxito del método, ya que la estructura de datos del cromosoma define el espacio de soluciones del problema (en la mayoría 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 más comunes trabajan con listas lineales, con excepción de la programación genética, donde se trabaja con estructuras en árbol.

1.2.2.2. Codificación Binaria Es la más común por razones históricas, ya que Holland concentró su trabajo en dicha configuración y en la practica, muchos desarrolladores de algoritmos genéticos han tendido a seguir este esquema. Además, mucha de la teoría existente sobre algoritmos genéticos se basa en la suposición de codificación de longitud fija y codificación binaria. Otro aspecto a considerar, es que independientemente de cualquier consideración, toda codificación 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 genéticos.

1.2.2.3. Codificación con Caracteres y Valores Reales Sin embargo, para muchos problemas, la codificación binaria no es natural y no es tan ampliamente utilizada, por ejemplo en aprendizaje evolutivo de Redes Neuronales Artificiales, para la representación de los pesos, o en la solución de problemas de Programación Lineal. Para muchas aplicaciones, es más natural usar un alfabeto de muchos caracteres o de números reales, para formar cromosomas. El Teorema del Algoritmo Genético, sin embargo, parece implicar que los GAs, presentan un comportamiento inferior cuando se hace la codificación con múltiples caracteres, que con codificación binaria. Sin embargo, esto es muy cuestionable, pues varias comparaciones empíricas entre codificación binaria y codificación 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 genético que se esta usando y en este momento aún no hay una guía rigurosa para predecir que codificación trabajará mejor.

1.2.2.4. Estructura en Árbol La codificación en árboles, como en la Programación Genética, de John Koza, donde cada cromosoma es un programa de computador, tiene varias ventajas, como la formación de soluciones más estructuradas y jerárquicas y que permiten que el espacio de búsqueda 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 difíciles de comprender y simplificar. Hasta ahora, la comunidad de la programación genética ha comenzado experimentos sistemáticos, que evalúan la utilidad de la codificación de árboles, comparándolos con otras codificaciones. Hasta cuando la teoría de algoritmos genéticos y su codificación, se formule de una manera más eficaz, la mejor filosofía es estudiar los ejemplos presentados en la literatura y adecuarlos a la versión particular del algoritmo genético.

16

1.2.2.5. Algoritmo Genético Simple General A continuación, se presenta un algoritmo genético general y universal, que con pocas modificaciones puede utilizarse para muchas aplicaciones. Producir la población inicial de individuos. Evaluar la Aptitud de todos los individuos. Mientras no se cumpla la condición de terminación Haga. Seleccione los individuos más aptos para reproducción Recombine los individuos seleccionados. Mute algunos individuos. Evalúe la aptitud de los nuevos individuos.

Genere una nueva población insertando algunos “buenos” individuos y descarte algunos “malos” individuos.

Fin Mientras.

1.2.2.5.1. Obtención de la Primera Generación La primera generación se produce aleatoriamente, con una población 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 1’s y 0’s, y posteriormente la población. Esta es una rutina universal para todos los algoritmos genéticos simples.

1.2.2.5.2. Evaluación de las Cadenas Una vez se tiene la primera generación 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 selección como progenitor de seres para la próxima generación. Para esto se le aplica la función de adaptabilidad o aptitud. Inicialmente se calcula el valor de decodificación 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. Selección de Estructuras La selección o reproducción, es un proceso en que las cadenas individuales se copian de acuerdo a los valores se su función objetivo f. Los biólogos la llaman función de adaptabilidad. La copia de cadenas se efectúa con base en el valor con que cada cadena contribuye a la adaptabilidad total de la población. Obteniendo la probabilidad acumulada para cada individuo:

ci = ∑ pi Un número aleatorio r, uniformemente distribuido en el rango [0,1], es generado tantas veces como individuos existen en la población (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 selección en una ruleta dividida en K segmentos cada una con un tamaño proporcional a la aptitud del individuo que representa. Con este tipo de selección de ruleta, los individuos más aptos tienen una mayor probabilidad de ser escogidos para reproducción. Este operador, claramente, es una versión artificial de selección natural, se busca un superviviente Darviniano de los más 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 obstáculos para llegar a adultos y reproducir las criaturas siguientes. Una vez la población ha sido seleccionada, las cadenas se forman en parejas aleatorias y se recombinan a través del cruce

1.2.2.5.4. Cruzamiento Después de la reproducción, 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 generación. Dado que fueron seleccionadas aleatoriamente tenemos una buena distribución. Cada par de cadenas se cruza como sigue: se selecciona uniformemente una posición 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 posición j en adelante de las dos cadenas, creándose 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 elección de un número 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 generación: A1' = 0 1 1 ‘ 0 1 A2' = 1 1 0 ‘ 0 0

18

Los dos nuevos individuos reemplazan a sus padres en la población de la siguiente generación. El operador de cruce es aplicado con una cierta frecuencia pc, llamada tasa de cruzamiento; cualquier individuo toma parte en el proceso de recombinación si una variable aleatoria uniformemente distribuida en el intervalo [0,1] tiene un valor ≤pc. Un valor empírico usual para pc es 0.6. Como se puede observar, los mecanismos de reproducción y cruce son sorprendentemente simples. Incluyen la generación de números aleatorios, copia de cadenas, y cierto intercambio parcial de cadenas. Sin embargo, el énfasis combinado de reproducción y el intercambio estructurado de información, aunque al azar, da a los GAs mucha de su potencia.

1.2.2.5.5. Mutación de Cadenas La mutación juega un papel secundario en los A.G., debido a que la frecuencia con que se realiza es extremadamente baja (empíricamente es aplicada con una frecuencia pm=0.01). En el caso estándar un número aleatorio r es generado (con distribución uniforme [0,1]) para cada bit de la población; 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 mutación, como en la ruleta y selecciona un bit de toda la población. Este operador permite que haya exploración en otras partes del espacio de búsqueda de manera que haya una completa exploración para evitar la concentración de los genes en máximos locales. 1.2.3. Otras Características

1.2.3.1. Métodos de Selección Después de decidir sobre la codificación del cromosoma, la segunda definición importante que se debe tomar al usar un algoritmo genético, es cómo efectuar la selección, es decir, como escoger los individuos para crear la descendencia en la siguiente generación. El propósito de la selección es, naturalmente, destacar los mejores individuos en la población, con la esperanza de que su descendencia tenga a su vez una aptitud mucho más alta. La selección tiene que hacer un balance entre la variación del cruce y la mutación, es decir, un balance entre explotación y exploración. Una selección que hace mucho énfasis en la aptitud, lleva a que individuos aptos, altamente subóptimos, se tomen la población, reduciendo la diversidad necesaria para el cambio y progreso posteriores. Una selección que hace poco énfasis en la aptitud, producirá una evolución demasiado lenta y ruidosa. Así como en la codificación, se han propuesto numerosos métodos de selección en la literatura. A continuación se describen los más comunes.

19

1.2.3.1.1. Selección Proporcional a la Aptitud con Juego de Ruleta El algoritmo genético original de Holland usó la selección proporcional a la aptitud, en la cual el valor esperado de reproducción de un individuo, es decir, el número de veces que se selecciona ese individuo, es la aptitud de ese individuo dividida por la aptitud promedio de la población. El método más común para implementarlo, es el de la ruleta descrito anteriormente, donde a cada individuo se le asigna un arco del círculo de la ruleta, correspondiente a la aptitud del individuo. La rueda se gira el número veces que sea necesario, hasta seleccionar el número de individuos de la población. Con la selección proporcional a la aptitud, se pone demasiado énfasis en la explotación de cadenas altamente aptas, a expensas de hacer exploración de otras regiones del espacio de búsqueda. Es decir, la evolución depende de la varianza de la aptitud en la población. Después de un número de generaciones, los individuos en la población son muy similares, no hay verdaderas diferencias en la aptitud, por lo que no se puede hacer más explotación, frenando la evolución.

1.2.3.1.2. Escalización Sigma Para tratar tales problemas, los investigadores de GAs han experimentado con varios métodos de escalización, métodos 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 desviación estándar de las aptitudes es normalmente alta, los individuos más aptos no tendrán desviaciones estándar arriba de la media, y así no se destinarán a compartir la descendencia. Asimismo, en la corrida, cuando la población es normalmente más convergente y la desviación estándar normalmente es baja, los individuos más aptos permanecerán fuera, permitiendo que la evolución pueda continuar.

1.2.3.1.3. Elitismo Es una adición a muchos métodos de selección que obliga al A.G. a retener algunos de los mejores individuos, que pueden perderse si no se seleccionan para reproducción o si se destruyen por el cruce o la mutación. Muchos investigadores han encontrado que el elitismo mejora significativamente el desempeño del algoritmo genético simple.

1.2.3.1.4. Selección por Clasificación La selección por clasificación es un método alternativo, cuyo propósito es también impedir la convergencia demasiado rápida. Los individuos de la población se ordenan de acuerdo a la aptitud, y el valor esperado de cada individuo, depende de su clasificación más 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 más cercano. La formación de clases evita darle a los más lejanos, compartir 20

mucho la descendencia, con un grupo pequeño altamente apto, y así reducir la presión de selección, cuando la varianza de la aptitud es alta. También mantiene la presión de selección cuando la varianza es baja: la relación 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. Selección por Torneo Los métodos proporcionales a la aptitud descritos anteriormente, requieren dos pasos a través de la población en cada generación: un paso para calcular la aptitud media, y otro paso, para calcular el valor esperado de cada individuo. El escalamiento por clasificación, requiere el ordenamiento de toda la población por clase, un procedimiento que potencialmente consume mucho tiempo. La selección por torneo es similar a la selección por clasificación, en términos de presión de selección, pero es computacionalmente más eficiente y más apropiada para la implementación paralela. Se escogen aleatoriamente dos individuos de la población. Luego se escoge un número aleatorio r entre 0 y 1. Si r < k, (donde k es un parámetro, por ejemplo 0.75), se selecciona el más apto de los dos individuos para ser padre; de otra manera se selecciona el individuo menos apto. Luego se devuelven los dos a la población original y se pueden seleccionar otra vez.

1.2.3.2. Operadores Genéticos La tercera discusión que se debe adelantar en la implementación de un A.G. es qué operadores genéticos va a usar. La decisión depende en primer lugar de la codificación definida y en segundo lugar de la función de aptitud. Se discuten aquí el cruce y la mutación, especialmente en el contexto de codificación con cadenas de bits.

1.2.3.2.1. Cruce Se puede decir que es la característica principal de un AG. El cruce en un solo punto es la forma más común y simple. La idea es combinar bloques de construcción, 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 destrucción. 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 daña con menor probabilidad esquemas con longitudes definidas largas y puede combinar más esquemas que el cruce de un solo punto. Además, los segmentos que se intercambian no necesariamente contienen los puntos extremos de las cadenas. También hay esquemas que el cruce de dos puntos no puede combinar.

21

Algunos tipos de codificación requieren operadores de cruce y mutación específicamente definidos, como en el caso de la programación genética cuya codificación es en árbol, o para solución de problemas de programación lineal. Los comentarios anteriores suponen que la razón de ser del cruce es la habilidad de recombinar esquemas altamente aptos. Se podría preguntar si no se debe considerar la posibilidad de que el cruce sea realmente útil por alguna razón completamente diferente, por ejemplo, como un operador de "macromutación" que simplemente permite grandes saltos en el espacio de búsqueda, este es un aspecto abierto en la investigación de GAs.

1.2.3.2.2. Mutación Un punto de vista común 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 variación e innovación en los GAs, y la mutación como una garantía de que no haya una permanente fijación en cualquier posición particular, jugando así un papel secundario. Esto difiere de las posiciones tradicionales de otros métodos de computación evolucionaria, como la programación genética, en la cual la mutación aleatoria es la única fuente de variación. Sin embargo, la aparición del papel de la mutación 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 mutación contra el cruce. Se ha verificado formalmente que, mientras la mutación y el cruce tienen la misma habilidad de "destruir" esquemas existentes, el cruce es un "constructor" más robusto de nuevos esquemas. También 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 mutación se ha subestimado en los GAs tradicionales". La elección no es entre cruce o mutación sino el balance entre cruce, mutación y selección ya que todo es importante. El balance correcto también depende de la función de aptitud y de la codificación Además, el cruce y la mutación varían en utilidad relativa en el curso de una corrida.

1.3. PROGRAMACION GENETICA 1.3.1. Introducción La programación genética es una especialización de los Algoritmos Genéticos, en la cual las estructuras computacionales que sufren la adaptación son en si mismas programas de computador. Basados en la teoría Darviniana de la aptitud, se aplica esta por medio de operadores genéticos especializados que generalizan la recombinación sexual y la mutación. Además, las estructuras sobre las que se aplican dichos operadores son programas jerárquicos con variación dinámica en forma y tamaño representados a su vez en estructuras de datos en árbol[1]. El espacio de búsqueda en la Programación Genética 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 aritméticas estándar, operaciones de programación estándar, funciones matemáticas estándar, funciones lógicas, o funciones especificas del dominio. La Programación Genética es la evolución directa de programas de computador[3]. Así, en casi todos los casos el material genético que está evolucionando es en cierto sentido ejecutable. Generalmente las estructuras son interpretadas, a veces en un lenguaje idéntico o muy parecido a un lenguaje de computación existente, a veces en un lenguaje diseñado para el problema a mano. Sin embargo, en casi todos los casos hay un concepto de ejecución del material genético, por algún interpretador, con el objeto de ver el comportamiento de la función deseada, a partir de la cual se obtiene la aptitud. 1.3.2. Selección del Lenguaje de Programación Todos los programas de computador, están escritos en Visual Basic, C++, código de ensamble, o cualquier otro lenguaje de programación (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 análisis gramatical; para luego convertir dicho árbol en instrucciones más elementales de código de ensamble que son las realmente interpretadas por el computador. Sin embargo, puesto que inicialmente la Programación Genética crea aleatoriamente programas de computador y luego los manipula genéticamente, la Programación Genética se puede implementar en forma directa en un lenguaje de programación que permita su fácil manipulación como datos (árboles) y luego permitan que esos datos creados recientemente se puedan ejecutar como programas. Por estas dos razones el lenguaje de programación LISP (LISt Processing), es especialmente apropiado para la Programación Genética. Sin embargo, se debe reconocer que la Programación Genética no requiere el LISP para su implementación 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 mayoría encuentra conveniente usar el estilo del LISP para presentar y diseñar programas evolucionados por Programación Genética[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 colección ordenada de elementos dentro de un par de paréntesis. Ejemplos de listas son (dos + tres) y (+ 1 2). Tanto las listas como los átomos en LISP se llaman expresiones simbólicas (S-expresiones). La S-expresión es la única forma sintáctica en LISP puro[1]. No hay distinción sintáctica 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 evalúa en sí mismo, y un átomo variable (por ejemplo, TIEMPO), LISP evalúa el valor corriente de la variable. Cuando LISP ve una lista, evalúa la lista (cualquier cosa al lado del paréntesis izquierdo) como una función que causa la aplicación de esa función a los resultados de la evaluación de los elementos restantes de la lista. Si un argumento es un átomo constante o un 23

átomo variable, la evaluación es inmediata; sin embargo, si el argumento es una lista, la evaluación de dicho argumento incluye una aplicación recursiva de los pasos anteriores. Por ejemplo, en la S-expresión LISP (+ 2 3), la función suma aparece al inicio del paréntesis izquierdo. La S-expresión (+ 2 3) hace un llamado para que se aplique la función adición + 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 evaluación de toda la S-expresión (+ 2 3) es 5. Si cualquiera de los argumentos en una S-expresión, es en sí misma una lista, en lugar de ser átomos constantes y variables que se pueden evaluar directamente, primero LISP evalúa estos argumentos. En Common LISP, esta evaluación se hace en forma recursiva y primero en profundidad. Por ejemplo, la S-expresión (+ (* 2 3) 4) hace un llamado para que se aplique la función adición + a los dos argumentos, nominalmente a la S-expresión (* 2 3) y al átomo constante 4. Este argumento (* 2 3) hace un llamado para que se aplique la función * a los dos átomos constantes 2 y 3, obteniendo 6, y la evaluación de la S-expresión completa (+ 6 4) es 10. Las S-expresiones LISP son ejemplos de notación prefija. Fortran, Pascal y C son similares a la notación matemática común ”infija”, de manera que el programa LISP anterior podría escribirse en esos lenguajes como 2 * 3 + 4. Por ejemplo, con la S-expresión LISP:

(+ 1 2 (IF (> TIEMPO 10) 3 4)) En la S-expresión (> TIEMPO 10), la relación > se ve como una función y > se aplica al átomo variable TIEMPO y al átomo constante 10. La S-expresión (> TIEMPO 10) evalúa 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 función que se aplica a tres argumentos: (> TIEMPO 10), el valor lógico que retorna (TRUE o NILL); el átomo constante 3; y el átomo constante 4. Si su primer argumento se evalúo en TRUE (más precisamente, cualquier valor diferente a NILL), la función IF retorna el resultado de evaluar su segundo argumento, (es decir, el átomo constante 3), pero si su primer argumento se evalúo en NILL, la función IF retorna el resultado de evaluar su tercer argumento (es decir, el átomo constante 4). Así, la S-expresión evalúa 6 o 7, dependiendo de que el valor del átomo variable TIEMPO sea o no mayor de 10. La mayoría de los lenguajes de programación crean formas sintácticas 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-expresión LISP (+ 1 2 (IF (> TIEMPO 10) 3 4)) dibujada como un árbol con

los nodos rotulados y las ramas ordenadas[3]. Cualquier S-expresión LISP se puede representar gráficamente como un árbol rotulado con ramas orientadas. La Figura 1 muestra el árbol de análisis gramatical (árbol del programa) correspondiente a la S-expresión descrita anteriormente. En esta representación gráfica, 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 raíz del árbol se rotula con la función que aparece más a la izquierda del paréntesis izquierdo de la S-expresión (es decir, el +). Obsérvese que esta forma de árbol de una S-expresión LISP es equivalente al árbol de análisis gramatical, que muchos compiladores construyen internamente para representar un programa de computador dado. Una característica importante de LISP es que todos los programas de computador LISP tienen solo una forma sintáctica (es decir, la S-expresión). Los programas del lenguaje de programación LISP son S-expresiones, y una S-expresión es, en efecto, el árbol de análisis gramatical del programa.

1.3.2.1 Por Que LISP A continuación se enumeran algunas características por las cuales el lenguaje LISP es el más usado y adecuado para la implementación de la Programación genética[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 población genética como dato de tal forma que este pueda ser manipulada genéticamente. Además es conveniente para inmediatamente ejecutar el resultado de la manipulación como un programa.

• La anterior forma común, de programas y datos en LISP (las S-expresiones) es equivalente al

árbol sintáctico para el programa de computador. A pesar de su apariencia exteriormente

25

diferente y sintáctica, muchos lenguajes de “compilación” internamente convierten en tiempo de compilación un programa dado en un árbol sintáctico de capas superpuestas de funciones y terminales de dicho programa. En muchos lenguajes de programación, este árbol sintáctico no es accesible (o por lo menos no convenientemente) al programador. Y, si este fuera accesible este podría tener una apariencia y sintaxis diferente a la de el lenguaje de programación mismo. Es necesario acceder al árbol sintáctico porque lo que se desea es manipular genéticamente las partes del programa (sub-árboles del árbol sintáctico). LISP brinda la forma conveniente de acceso a este árbol sintáctico, porque la S-expresión es en sí misma un árbol sintáctico.

• La función de evaluación provee una forma muy sencilla de ejecutar un programa que fue

creado o manipulado genéticamente. • LISP facilita la programación de estructuras que pueden cambiar dinámicamente en tamaño y

forma, sin restricciones de tamaño ni almacenamiento. • Es importante notar que lo que se utiliza no es como tal lenguaje LISP sino, el

comportamiento que este presenta con sus datos en forma de S-expresiones. 1.3.3. Características de la Programación Genética Se puede observar que el caso de la programación genética, no es más que una especialización del algoritmo genético simple expuesto anteriormente, el cual, replanteado para la programación genética, tendría la siguiente forma[3]: Genere una población inicial de composiciones aleatorias de funciones y terminales del problema (programas de computador). Mientras no se cumpla a satisfacción el criterio de terminación Haga

Ejecute cada programa de la población y asígnele de acuerdo a qué tan bien soluciona el problema un valor de aptitud. Cree una nueva población de programas aplicando los dos operadores primarios (cruce y mutación) con algún criterio de selección definido. Copie los programas existentes a la nueva población.

Cree nuevos programas por medio de la generación aleatoria.

Fin mientras El programa más apto de la población al momento de la terminación del ciclo anterior, es designado como el resultado de la programación genética.

26

Al analizar el algoritmo anterior podemos entonces comenzar a describir el paradigma de la programación genética, en términos de:

• las estructuras que sufren adaptación, • las estructuras iniciales, • la medida de aptitud que evalúa las estructuras, • las operaciones que se realizan para modificar las estructuras, • el estado (memoria) del sistema en cada fase, • el método para designar un resultado, • el método para terminar el proceso y • los parámetros que controlan el proceso.

1.3.3.1. Las Estructuras que Sufren Adaptación En cada sistema adaptativo o de aprendizaje, alguna estructura o estructuras están sufriendo adaptación. Para los algoritmos no-genéticos adaptativos, la estructura que sufre adaptación es típicamente un solo punto en el espacio de búsqueda del problema. Para los algoritmos genéticos convencionales y la programación genética, las estructuras que sufren adaptación son puntos individuales, en una población de puntos del espacio de búsqueda del problema. Es decir, la aproximación genética involucra una búsqueda paralela. Las estructuras individuales que sufren adaptación en la programación genética son programas de computadora jerárquicamente estructurados. El tamaño, forma, y complejidad de éstos programas de computadora pueden cambiar dinámicamente durante el proceso. El juego de posibles estructuras en el paradigma de la programación genética 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 términos terminales del conjunto fijo de terminales T = {a1, a2,..., aNterm}. Cada función particular f en F toma un número z(f) de argumentos b1, b2,…, bz(f). Las funciones en el conjunto de funciones pueden ser: • funciones aritméticas (+, -, *, etc.), • funciones matemáticas (como Seno, Coseno, Exp, etc.), • operadores booleanos (como AND, OR, NOT), • operadores lógicos (como If-Then-Else), • operadores iterativos (como Do-Until), • funciones que permiten recursión y • funciones de dominio especifico. Las terminales son típicamente cualquiera átomos constantes (como el número 3) o los átomos variables (representando, quizás, las entradas, sensores, o las variables de estado de algún sistema). Considérese 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 función de igualdad con dos argumentos. Esta función devuelve TRUE (Verdadero) si los dos argumentos son iguales; por otra parte, esta función devuelve NILL (Falso). Esta función booleana puede expresarse en forma normal disyuntiva (DNF) y representada por la S-expresión LISP:

(OR(AND (NOT D0) (NOT D1)) (AND D0 D1)). El árbol ordenado que corresponde a la S-expresión anterior para la función de paridad igual con dos argumentos se muestra en la Figura 2.

Figura 2 Arbol LISP correspondiente a la S-expresión (OR (AND(NOT D0) (NOT D1))

(AND D0 D1)) En esta descripción gráfica, 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 raíz del árbol se etiqueta con la función que aparece en paréntesis izquierdo extremo de la S-expresión LISP (es decir OR). El espacio de búsqueda para el paradigma de la programación genética es el hiperespacio de S-expresiones LISP que pueden ser creadas recursivamente por composiciones de las funciones y términos disponibles para el problema. Este espacio de búsqueda 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 adaptación en el paradigma de la programación genética son diferentes de las estructuras que sufren adaptación en el algoritmo genético convencional que opera en cadenas. Las estructuras que sufren adaptación en el paradigma de la programación genética son estructuras jerárquicas. 28

Usando la programación genética, 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 función en el conjunto de funciones debe ser bien definida para cualquier combinación de argumentos que pueda encontrarse. Estos valores de argumento pueden venir de una terminal o una función. Por ejemplo, si el conjunto de funciones es el de las funciones booleanas AND y OR, y el conjunto de terminales sólo consiste en variables booleanas que pueden asumir sólo los valores de TRUE o NILL, entonces la propiedad del cierre se satisfará. Por otro lado, si la operación aritmética de división está en el conjunto de funciones junto con términos que pueden asumir el valor numérico cero, la propiedad del cierre no se cumplirá a menos que algún arreglo se haga al tratar con la situación cuando se intenta la división por cero. Si la propiedad del cierre no prevalece, es necesario plantear alternativas como: (1) desechar a los individuos que no evalúan 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 podría inducir la Tercera Ley de Kepler para los periodos de los planetas alrededor del sol si el conjunto de terminales contiene sólo el diámetro de cada planeta (como opuesto a su distancia del sol) o si el conjunto de funciones tuviera sólo definidas la suma y la substracción (en lugar de las funciones necesarias para declarar la Tercera Ley). El usuario de la programación genética debe saber o creer que alguna composición de funciones y terminales que él proporciona pueden dar una solución al problema. En algunos dominios (ej. Funciones booleanas), los requisitos son bien conocidos. Por ejemplo, quitando la función 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 función de igualdad de dos terminales. La elección del conjunto de funciones y terminales disponibles, por supuesto, afecta el carácter 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 programación genética consisten en los individuos en la población inicial de S-expresiones individuales para el problema.

29

La generación de cada S-expresión individual en la población inicial es hecha generando al azar un árbol, con nodos etiquetados y ramas ordenadas que representan la S-expresión. Inicialmente se selecciona una de las funciones al azar del conjunto fijo F (usando una distribución uniforme) para ser la etiqueta para la raíz del árbol. Nótese que la selección de etiqueta para la raíz del árbol se restringe a las funciones fijas F puesto que se desea generar una estructura jerárquica, y no una estructura degenerada que consiste en un solo término. Por ejemplo, en la Figura 3, la función + (tomando dos argumentos) se seleccionó de un conjunto de funciones F como la etiqueta para la raíz del árbol donde z(f) es el número de argumentos tomado por la función f, se crea para radiar a partir de ese punto. Entonces, para cada línea de radiado, un elemento se selecciona al azar para ser la etiqueta para el punto de finalización de dicha línea de radiado.

Figura 3 La generación de un árbol aleatorio podría empezar con etiquetar la raíz del árbol con la función +.

Si una función es escogida para ser la etiqueta para cualquier punto de finalización, el proceso generador continúa entonces recursivamente como se describió anteriormente. Por ejemplo, en la Figura 4, la función * 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) línea de radiado del punto con la función +. Esta función * toma dos argumentos para las que se muestran dos líneas que radian fuera del punto con la función *.

Figura 4 La generación de un árbol aleatorio podría continuar con etiquetar un punto

interior con la función *. 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 línea radiada del punto etiquetado con la función *.

30

Figura 5 La generación de un árbol aleatorio podría 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 tamaños y formas. El método generador que se comporta mejor sobre un amplio rango de problemas es un método llamado "Inclinación media'', en la cual se produce una mezcla de árboles de varios tamaños y formas. Este método generador involucra la creación de un número igual de árboles cuya profundidad está entre dos y alguna profundidad máxima. La profundidad de un árbol es la longitud del camino más largo de la raíz 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 raíz es igual al máximo. Esto se logra restringiendo la selección aleatoria de la etiqueta para los puntos del árbol a profundidades más pequeñas que el máximo al conjunto de funciones F y restringiendo la selección aleatoria de la etiqueta para los puntos a profundidades que igualan al máximo 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 raíz no es mayor que el máximo especificado. Esto se cumple haciendo la selección aleatoria de la etiqueta para los puntos del árbol a profundidades más pequeñas que el máximo del conjunto combinado C = F ∪ T que consiste en la unión del conjunto de funciones F y el conjunto de terminales T, mientras se restringe la selección aleatoria de la etiqueta para los puntos a profundidades iguales al máximo al conjunto de terminales T.

Normalmente se utiliza una distribución de probabilidad uniforme para las selecciones anteriormente descritas. Los individuos duplicados son improductivos, implicando gasto de recursos computacionales y reducción de la diversidad genética de la población. En el paradigma de la programación genética, se crean a menudo individuos aleatorios dobles cuando el tamaño del árbol es pequeño o cuando el tamaño del conjunto de terminales es tan grande como el conjunto de funciones.

1.3.3.3. La Aptitud A cada individuo en una población se le asigna un valor de aptitud numérico como resultado de su interacción 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 terminología 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 S-expresiones en la población sobre diferentes situaciones representativas para las que un rango de valores de aptitud crudos numéricos diferentes pueda obtenerse. Los casos de aptitud son típicamente una muestra finita pequeña 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 definición 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-expresión para el conjunto de argumentos y el punto correcto en el espacio del rango para el caso de aptitud particular. La S-expresión puede ser evaluada como:

∑=

=EN

1jC(j)-j)S(i, t)r(i,

booleana, entera, real, compleja, o simbólica. Si la S-expresión 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 números involucrados. Cuando la aptitud cruda es el error, la aptitud cruda r(i,t) de una S-expresión i en la población de tamaño M a cualquier paso generacional t es: donde S(i,j) es el valor devuelto por la S-expresión 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-expresión es evaluada como booleana o simbólica, la suma de distancias es equivalente al número 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 satisfacción. Note que porque la aptitud cruda se declara en la terminología natural del problema, el mejor valor puede ser el más pequeño (como cuando la aptitud cruda es el error) o más 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 numérico más bajo sea mejor. Si un valor más 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 más alto de la aptitud cruda es mejor (ej. Cuando el alimento es ser ingerido), la aptitud regularizada iguala el máximo 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:

t))s(i,(11 t)a(i,

+=

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 más grande para los mejores individuos en la población. Si ningún 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 pequeñas en el valor de la aptitud regularizada como estos valores comienzan acercándose a cero en generaciones posteriores. La aptitud ajustada es especialmente beneficiosa si la aptitud regularizada alcanza el valor cero cuando una solución perfecta al problema es encontrada (ej. Como en problemas de la regresión simbólica 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:

∑=

= M

k

tka

tiatin

1

),(

),(),(

La aptitud normalizada tiene tres características deseables: • Se encuentra en el intervalo [0…1]. • Es más grande para los mejores individuos en la población. • La suma de los valores de aptitud normalizados es uno. También es posible que la función de aptitud le dé algún peso a los factores secundarios. Por ejemplo a la eficacia de la S-expresión.

33

1.3.3.4.Operaciones para la Modificación de Estructuras Las dos operaciones primarias para la modificación de estructuras que sufren adaptación en la programación genética son (1) reproducción Darviniana proporcional a la aptitud y (2) el cruce (recombinación sexual).

1.3.3.4.1. Reproducción La operación de reproducción para la programación genética es el motor básico de la reproducción Darviniana y la supervivencia del más apto. Cada vez que esta operación se efectúa, opera en sólo una S-expresión padre y produce sólo una S-expresión descendiente. Es decir, es una operación asexual. El funcionamiento de reproducción consiste en dos pasos. Primero, una sola S-expresión se selecciona de la población según alguna regla de selección basada en aptitud. Luego, el individuo se copia de la población actual a la nueva población (es decir la nueva generación). Hay muchas reglas de la selección basadas en aptitud. La regla de la selección más popular es la selección ruleta. Cuando se utiliza la selección por ruleta en la operación de reproducción, si f(si(t)) es la aptitud del individuo si en la generación t, entonces, cada vez que la operación de reproducción se realiza, cada individuo en la población tiene una probabilidad de ser copiada en la próxima generación así:

∑=

= M

jj

ii

tf

tf

ssp

1

))((

))((

Cuando el operador de reproducción ha sido aplicado con la selección por ruleta como regla de selección, se llama reproducción proporcional a la aptitud. Nótese que el padre permanece en la población mientras la selección se ha llevado a cabo durante la generación actual. Es decir pueden seleccionarse padres, y en general, se seleccionan, más de una vez para la reproducción durante la generación actual. De hecho, la proporción diferencial de supervivencia y reproducción para más individuos aptos es una parte esencial de algoritmos genéticos.

1.3.3.4.2. Cruce (Recombinación) El operador de cruce (recombinación) para la programación genética crea una variación en la población, 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 población con una probabilidad igual a su aptitud normalizada.

34

El operador comienza seleccionando independientemente y usando una distribución de probabilidad uniforme, un punto al azar en cada padre para ser el punto de cruce para ese padre. Nótese que el número de puntos en los dos padres no es típicamente igual porque las S-expresiones en la población son de varias formas y tamaños. El fragmento de cruce para un padre en particular es el sub-árbol cuya raíz 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-expresión, el fragmento de cruce es la sub-lista que empieza en el punto de cruce. La primera S-expresión 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 simétrica. Puede observarse como el operador de cruce es sintácticamente legal para cualquiera dos S-expresiones y dos puntos cualquiera de cruce. Por ejemplo, considérese 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 términos 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 función NOT. También 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 función 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. Nótese que el primer descendiente es una solución perfecta para la función 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)). Obsérvese además que puesto que los sub-árboles enteros son intercambiados, y debido a la propiedad del cierre de las funciones en si mismas, el operador genético de cruce (recombinación) produce una S-expresión LISP sintácticamente correcta como descendencia en todas las situaciones. Además es importante observar que si un individuo es emparentado con sí mismo o con un individuo idéntico, 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 genéticos 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 término del primer padre se inserta a la instancia del sub-árbol en el segundo padre. En este caso, la función 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 función de cruce intercambia 36

estos términos de árbol a árbol. El efecto del cruce, en este evento, es semejante a una mutación del punto. Así, la mutación del punto ocasional es una parte inherente de la función de cruce. Un máximo el tamaño permisible (de la profundidad del árbol) se establece para la descendencia creada por el operador de cruce. Este límite previene cantidades grandes de tiempo de máquina en S-expresiones sumamente grandes. Por supuesto, si fuese posible ejecutar todos las S-expresiones individuales en la población 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 población. Si un cruce entre dos padres creara una descendencia de tamaño imprevisible, el operador de cruce se aborta para esa descendencia y el primero de los padres se escoge ser reproducido arbitrariamente en la nueva población.

1.3.3.5. El Estado del Sistema El estado del sistema de programación genética a cualquier punto durante el proceso sólo consiste en la población actual de individuos en la población. No hay ninguna memoria adicional.

1.3.3.6. Designación del Resultado El único mejor individuo en la población en el momento de la terminación de la programación genética se designa típicamente como el resultado producido por el algoritmo. Este método de designación 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 población en el momento de la terminación a menos que algún esfuerzo específico se lleve a cabo para conservar a dicho individuo (por ejemplo aplicando una estrategia elitista). Alternamente, la población en su totalidad en el momento de la terminación de la programación genética puede designarse como el resultado producido por él.

1.3.3.7. Terminación En cuanto a la terminación, la programación genética es paralela a la naturaleza en que es un proceso continuo. Como un hecho práctico, la programación genética termina cuando un número de máximo de Ngen de generaciones ha sido alcanzado o cuando algún criterio de terminación ha sido satisfecho. Un criterio de terminación puede ser que la aptitud regularizada de algún individuo en la población sea igual a cero o esté dentro de una vecindad preestablecida cercana a cero.

37

1.3.3.8. Parámetros de Control La programación genética es controlada por varios parámetros; incluye dos parámetros mayores y cinco parámetros menores. Los dos parámetros mayores que se usan para controlar el proceso son el tamaño de la población M y el número de generaciones Ngen para ser ejecutado. Se usan cinco parámetros menores para controlar el proceso. Dos de ellos controlan la frecuencia con la que se realizan las operaciones genéticas; uno de ellos controla el porcentaje de (función) 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 población en cada generación (generalmente es de

90%). Es decir, si el tamaño de la población es 500, entonces 450 individuos (225 pares) de cada generación se seleccionan con una probabilidad igual a su aptitud normalizada (con re-selección permitida) para participar en el cruce.

2. la reproducción se aplica según el tipo de aptitud escogido (es generalmente el complemento de el porcentaje aplicado al cruce, p. ej. 10%) a la población en cada generación. Es decir, si el tamaño de la población es 500, se seleccionan 50 individuos de cada generación con una probabilidad igual a su aptitud (con re-selección permitida).

3. Tercero, se asigna una probabilidad de selección 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 máxima (generalmente es de 17) para S-expresiones creadas por cruce.

5. Se establece además una profundidad máxima (generalmente es de 6) para las S-expresiones generadas aleatoriamente en la población inicial.

1.3.4. Funciones Predefinidas En el paradigma de la programación genética, se presenta un método diseñado con el fin de descomponer el problema en subproblemas más simples, con el fin de ensamblar soluciones a estos dentro de una solución al problema completo. En el problema que nos atañe, estos subproblemas se refieren a la implementación de funciones booleanas de un número determinado de entradas y una sola salida, por ejemplo una función XOR de tres o más entradas, es de gran ayuda para la construcción de el sumador de 3 bits, así, entonces se supone que el usuario pueda definir estas funciones antes de comenzar la ejecución 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 población de individuos clonando el genoma de la población inicial. Cada generación, el algoritmo crea una población temporal de individuos, y los adiciona a la población existente, para luego remover los peores individuos de la población, con el fin de regresarla a su tamaño inicial. 38

1.4. CIRCUITOS LOGICOS COMBINATORIOS 1.4.1. Definición Un circuito lógico combinatorio es un dispositivo que se constituye por un conjunto de combinaciones de compuertas lógicas. En cualquier instante de tiempo, el nivel lógico de la salida depende de la combinación de los niveles lógicos en las entradas. Un circuito combinatorio no posee memoria, ya que solo depende del valor de las entradas actuales del sistema.

M variables de

Salida N variables de

Entrada

CIRCUITO LÓGICO

COMBINACIONAL

Figura 9 Esquema de un circuito lógico combinacional. Un circuito lógico 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 número de combinaciones posibles está dado por 2N, donde N es el número de entradas.

Entrada 0 Entrada 1 Salida x y z 0 0 1 0 1 0 1 0 0 1 1 1

Tabla 1 Combinaciones Posibles Sin embargo, en muchos circuitos, solo un subconjunto de esas combinaciones produce una salida. Además, de los circuitos lógicos combinatorios, existen los circuitos secuenciales, que se forman por un conjuntos de circuitos combinatorios y elementos de memoria.

Elementos de Memoria

M variables de Salida

N variables de Entrada

CIRCUITO LÓGICO SECUENCIAL

Figura 10 Esquema de un circuito lógico secuencial.

39

1.4.2. Lógica Binaria En la lógica 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 lógicos

0 1 FALSO VERDADERO

BAJO VOLTAJE ALTO VOLTAJE NO 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 términos prácticos, 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 lógica binaria existen variables booleanas y operaciones booleanas. Las variables por lo general se identifican mediante letras del alfabeto. En esta lógica existen solamente tres operaciones básicas: 1. Adición 2. Multiplicación 3. Complementación o inversión

1.4.2.1. Adición Lógica La tabla de verdad que describe el comportamiento de la adición lógica se muestra a continuación:

A B X = A+B 0 0 0 0 1 1 1 0 1 1 1 1

Tabla 3 Tabla de verdad de la adición lógica Dicha operación se representa por medio del símbolo “+”. Entonces, si X es el resultado de realizar una adición lógica entre A y B, X se expresa de la siguiente forma:

X=A+B La expresión anterior también se puede leer como “X igual a A OR B”. la figura 11 representa el símbolo de la compuerta OR utilizado en la etapa de diseño y documentación de un circuito. 40

Figura 11 Compuerta OR.

1.4.2.2. Multiplicación Lógica La siguiente es la tabla de verdad que describe el comportamiento de la multiplicación lógica.

A B X = AB 0 0 0 0 1 0 1 0 0 1 1 1

Tabla 4 Tabla de verdad de la multiplicación lógica Esta operación se representa por medio de un punto o por la ausencia de operador. Así, si dos variables lógicas A y B se combinan por medio de una multiplicación lógica (denominada AND), el resultado puede expresarse de la siguiente manera:

X=AB Como se observa en la tabla, la operación de multiplicación lógica se asemeja a la multiplicación presente en el álgebra ordinaria, ya que el producto de dos números que pueden tomar valores 0 o 1 solo puede ser 1 si ambos operandos lo son también. La figura 12 representa el símbolo de la compuerta AND utilizado en la etapa de diseño y documentación de un circuito.

Figura 12 Compuerta AND

1.4.2.3. Inversión Lógica Esta operación se realiza sobre una sola variable de entrada. La siguiente tabla describe el comportamiento de la inversión lógica.

41

A X = A’ 0 1 1 0 0 1 1 0

Tabla 5 Tabla de verdad de la inversión lógica

Dicha operación 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 operación se conoce también como inversión lógica o NOT. El símbolo utilizado para describir esta operación es el siguiente (Figura 13):

Figura 13 Negador.

Debe notarse que dentro del conjunto de estándares de diseño de circuitos, el círculo representa negación o inversión de la señal. 1.4.3. Otras Compuertas Lógicas Como se ha mencionado hasta ahora, las tres compuertas básicas (operaciones lógicas) son AND, OR y NOT. Con dichas operaciones se puede describir cualquier circuito lógico combinatorio sin importar su complejidad. Sin embargo, para el proyecto que se realiza, se tienen en cuenta otras tres compuertas que pueden simplificar el diseño 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 operación OR-Exclusiva, que se conoce también como XOR o EOR.

42

A B X = A⊕B 0 0 0 0 1 1 1 0 1 1 1 0

Tabla 6 Tabla de verdad de la compuerta XOR Si se relacionan las variables A y B por medio de esta operación, se escribe:

X= A ⊕ B Como se observa en la tabla, en esta operación se obtiene una salida de 1 cuando las variables de entrada son diferentes. Esta compuerta se obtiene utilizando las operaciones básicas de la siguiente forma:

X=A ⊕ B = AB’ + A’B El símbolo utilizado en el diseño 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 función 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 B X = A NAND B 0 0 1 0 1 1 1 0 1 1 1 0

Tabla 7 Tabla de verdad de la compuerta NAND El símbolo utilizado para representar una compuerta NAND en el diseño 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 operación 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 B X = A NOR B 0 0 1 0 1 0 1 0 0 1 1 0

Tabla 8 Tabla de verdad de la compuerta NOR El símbolo utilizado para representar una compuerta NOR en el diseño de circuitos es el siguiente (figura 16):

Figura 16 Compuerta NOR.

1.4.3.4. Importancia de las Compuertas Nand y Nor Un aspecto básico que debe tenerse en cuenta en el diseño de circuitos, es la universalidad de las compuertas NAND y NOR. Todas las expresiones booleanas se forman por la combinaciones de las compuertas básicas 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 relación existente entre las compuertas NAND y NOR y las compuertas básicas.

44

Figura 17 Equivalencias para diferentes compuertas.

Por lo anterior, en la etapa de implementación del diseño, 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. Diseño Analítico de Circuitos Lógicos Combinatorios Los siguientes son los pasos necesarios para realizar el diseño de circuitos lógicos combinatorios: 1. Describir el problema. 2. Determinar el número de variables de entrada y de salida necesarios. 3. Asignar letras que identifiquen las variables 4. Deducir la tabla de verdad que defina completamente el circuito necesario 5. Simplificar funciones 6. Dibujar el diagrama lógico obtenido La descripción del problema radica en la exposición detallada de la funcionalidad que debe tener el circuito. Entonces, el diseñador debe indicar cuantas variables (señales) de entrada y salida deben ser utilizadas. Por medios analíticos (dada una especificación 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 diseño para ser probado e implementado. En la siguiente sección, se exponen las características más importantes de la simplificación de funciones que se usa en el diseño de circuitos. 45

1.4.4.1. Simplificación de Funciones Para realizar el diseño analítico de circuitos lógicos, se debe expresar el comportamiento del sistema por medio de expresiones lógicas que se encuentren en forma de suma de productos. Cada una de las expresiones en una suma de productos, consta de varios términos AND (producto lógico) que se combinan por medio de operaciones OR (suma lógica). Además tiene una característica especial: En cada término no debe existir inversión lógica de más de una variable. La simplificación algebraica de un circuito lógico permite modificar un diseño original para que su implementación sea más sencilla y eficiente. Esto se logra en dos etapas: Uso de Mapas de Karnaugh, y teoremas DeMorgan para llevar una descripción a la forma de

suma de productos. Factorización matemática de la expresión.

1.4.4.2. Mapas De Karnaugh Este método 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 término mínimo (es decir, cada uno de los términos de una expresión que se encuentre en forma de suma de productos). En la práctica, su uso se reduce a circuitos con 6 variables de entrada como máximo. 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 podría ser el formato utilizado para el mapa de KARNAUGH.

B’ B A’ 1 1 A 0 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 intersección 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 B SALIDA 0 0 1 0 1 1 1 0 0 1 1 0

Tabla 10 Ejemplo de tabla de verdad

B’ B A’ 1 1 A 0 0

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 A’B’ y A’B. Por lo tanto, la expresión que representa el circuito es:

SALIDA = A’B’ + A’B Luego de haber obtenido la expresión del circuito, puede utilizarse una técnica que reemplaza a la factorización matemática denominada agrupamiento. El agrupamiento puede tomar dos celdas, cuatro, ocho, e incluso más. 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 expresión 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 más importantes que se utilizan para la simplificación de circuitos. Aunque la demostración de estos enunciados es sencilla e interesante, no se tratará en este documento.

X + 0 = X X1=X X+X’=1 XX’=0 X+X=X XX=X X+1=1 X0=0

47

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

Tabla 12 Teoremas de Boole y Morgan 1.4.5. Ejemplos En esta sección se pretende mostrar algunos ejemplos de circuitos lógicos combinatorios que son usados con frecuencia en la construcción 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 y CARRY SUMA 0 0 0 0 0 1 0 1 1 0 0 1 1 1 1 0

Tabla 13 Tabla de verdad del sumador medio

La expresión simplificada en forma de productos correspondiente a este circuito es:

SUMA = x’y + xy’ = x⊕y CARRY = xy

1.4.5.1.2. Sumador Total El sumador total (completo) es el circuito combinacional capaz de sumar lógicamente tres bits de entrada. La siguiente tabla de verdad muestra el comportamiento de este circuito: 48

x y z CARRY SUMA 0 0 0 0 0 0 0 1 0 1 0 1 0 0 1 0 1 1 1 0 1 0 0 0 1 1 0 1 1 0 1 1 0 1 0 1 1 1 1 1

Tabla 14 Tabla de verdad del sumador total Las expresiones que representan este circuito son:

SUMA= x’y’z + xy’z’ + x’yz’

CARRY = xy + xz + yz La suma de dos números binarios puede hacerse utilizando un conjunto de sumadores totales. Las dos primeras entradas (x, y) representan los bits que se sumarán. La tercera entrada (Z) puede corresponder al bit de acarreo de la posición previa menos significativa. En la figura 18, se observa el esquema lógico de un sumador de tres bits usando Sumadores Totales.

Carry 2

NUMERO B

NUMERO A

Carry M

Suma Suma 1 Suma 0

Carry M-1 Carry 1

SUMADOR

TOTAL

No. M

SUMADOR

TOTAL

No. 2

SUMADOR

TOTAL

No. 1

Carry 0

Figura 18 Esquema lógico 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 diseño 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 y B D 0 0 0 0 0 1 1 1 1 0 0 1 1 0 1 0

Tabla 15 Tabla de verdad del sustractor medio La expresión de este circuito es:

D = x’y + xy’

B = x’y 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 y z B D 0 0 0 0 0 0 0 1 1 1 0 1 0 1 1 0 1 1 1 0 1 0 0 0 1 1 0 1 0 0 1 1 0 0 0 1 1 1 1 1

Tabla 16 Tabla de verdad del sustractor completo

50

La expresión de un sumador completo está dada por:

D = x’y’z + x’yz’ + xy’z’+ xyz B = x’y + x’z +yz

Debe notarse que la salida D de este circuito es igual a la salida S del sumador completo.

1.4.5.3. Relación Entre Sumadores y Sustractores Es posible convertir un sumador completo a un sustractor completo complementando la entrada x antes de su aplicación 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 números binarios consisten invertir todas las entradas del sustraendo y utilizar el primer acarreo Co con un valor de 1.

1.4.5.4. Generación y Comprobación 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 continuación:

x y z PARIDAD IMPAR 0 0 0 1 0 0 1 0 0 1 0 0 0 1 1 1 1 0 0 0 1 0 1 1 1 1 0 1 1 1 1 0

Tabla 17 Tabla de verdad del generador de paridad impar La expresión de este circuito está dada por:

P = x ⊕ y (•)z Donde (•) se conoce como operador de equivalencia. Su tabla de verdad es:

51

A B X = A(•)B 0 0 1 0 1 0 1 0 0 1 1 1

Tabla 18 Tabla de verdad del operador de equivalencia Cuando se recibe la transmisión, 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 y z P COMPROBACION 0 0 0 0 1 0 0 0 1 0 0 0 1 0 0 0 0 1 1 1 0 1 0 0 0 0 1 0 1 1 0 1 1 0 1 0 1 1 1 0 1 0 0 0 0 1 0 0 1 1 1 0 1 0 1 1 0 1 1 0 1 1 0 0 1 1 1 0 1 0 1 1 1 0 0 1 1 1 1 1

Tabla 19 Tabla de verdad del circuito de comprobación de paridad impar La expresión que describe este circuito es:

C = x (•)y(•)z(•)P

1.4.5.5. Decodificadores Un decodificador es un circuito combinacional que convierte la información binaria de n líneas de entrada a un máximo de 2n líneas únicas de salida. Se denomina a un decodificador en línea 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 línea de 2 a 4

52

x y D0 D1 D2 D3 0 0 1 0 0 0 0 1 0 1 0 0 1 0 0 0 1 0 1 1 0 0 0 1

Tabla 20 Tabla de verdad de un circuito decodificador de línea de 2 a 4

1.5. LENGUAJE VHDL VHDL es un lenguaje de programación diseñado para describir el comportamiento de circuitos digitales. 1.5.1. Introducción 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 Descripción de Hardware para circuitos integrados de alta velocidad.

1.5.1.1. Breve Reseña Histórica VHDL fue desarrollado a principios de los años 80s, como un proyecto de investigación del Departamento de Defensa de los Estados Unidos de América. El desarrollo del lenguaje siguió su camino por varios años, hasta que se presentó en el año de 1985 una versión comercial (versión 7.2); con la ayuda de ingenieros de compañías como IBM, Texas Instruments e Intermetrics En 1986, la IEEE propuso la estandarización del lenguaje, lo que permitió en 1987 la creación del lenguaje VHDL tal como se conoce hoy día. El resultado, el estándar IEEE 1076-1987. Sin embargo se han elaborado revisiones hasta el año de 1994, pero el comportamiento básico del lenguaje permanece intacto.

1.5.1.2. Características Entre las principales características de VHDL encontramos las siguientes: Lenguaje de Simulación.

VHDL posee las herramientas necesarias para describir la funcionalidad de componentes electrónicos. En el se puede detallar el comportamiento de simples compuertas lógicas o complejos microprocesadores. VHDL permite el manejo de aspectos electrónicos, tales como la activación y desactivación de señales y los tiempos de demora entre las compuertas, entre otros. 53

Lenguaje de Diseño.

Como cualquier lenguaje de alto nivel (Pascal, C o C++), VHDL posee un conjunto de sentencias y comandos útiles para el diseño estructurado de circuitos, y ofrece un conjunto de control y representación de datos. A diferencia de los otros lenguajes de programación, VHDL ha sido diseñado para que una gran cantidad de procesos que ocurren concurrentemente puedan ser diseñados. Lenguaje de Prueba.

Una de las características más sobresalientes de VHDL es su habilidad para capturar una especificación de rendimiento para un circuito. Comúnmente llamado Test Bench. Esta especificación corresponde a las salidas esperadas de acuerdo a un conjunto de estímulos dados. VHDL es un lenguaje que permite el diseño en alto nivel de circuitos digitales. Pero también es usado para representar diseños en forma de bajo nivel, lo que permite la comunicación con otras herramientas Puede reemplazar lenguajes Netlist como EDIF (un lenguaje Netlist, define una lista de componentes y conexiones digitales) Lenguaje Estándar

EL uso de VHDL radica además en que es un lenguaje adoptado por la comunidad electrónica. Cuando se usa un lenguaje estándar como VHDL se garantiza que los diseños son soportados por las herramientas de captura de diseño actuales y futuras. Además, se puede hacer uso de una gran cantidad de librerías y código que puede ser accesible desde bibliotecas o desde Internet.

1.5.1.3. Ventajas VHDL puede ser usado para el diseño 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 diseño. En esta fase, el usuario puede expresar el diseño (o partes de este) como diseño esquemático (schematics), o por medio de descripciones VHDL. En la captura del diseño muchas veces se incluyen herramientas que complementan el lenguaje. Por ejemplo, el uso de representaciones gráficas que reemplazan segmentos de código. Si se desea simular la operación 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 programación estructurada de VHDL, permiten que este lenguaje sea una gran herramienta natural para la documentación de circuitos complejos.

54

Un ejemplo claro de esta funcionalidad, radica precisamente en el Departamento de Defensa de los Estados Unidos de América. Cualquier nuevo diseño electrónico debe documentarse en VHDL para permitir la fiel comunicación entre los subcontratistas de esta entidad. El diseño esquemático (Schematics) siempre ha tenido un gran uso en el diseño electrónico. Por esta razón, la herramientas de diseño VHDL poseen la capacidad de interactuar con diseños esquemáticos para obtener diseños altamente eficientes e integrales. Existe un conjunto extenso de lenguajes para la programación de dispositivos lógicos, que son lenguajes propietarios de cada uno de los fabricantes de circuitos. Entre los más 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 visión popular de los nuevos diseñadores que piensan que es un lenguaje demasiado extenso y complejo. Sin embargo, como se muestra en esta investigación, conociendo unas pocas reglas sintácticas y algunos comandos, se pueden representar una gran cantidad de circuitos. Las herramientas de diseño para VHDL por lo general han tenido un costo más alto que las otras que se encuentran en el mercado. Aunque en la actualidad, con el uso de circuitos lógicos reprogramables como FPGA, los vendedores ofrecen herramientas de bajo costo, que se integran a sistemas de síntesis, simulación y programación. 1.5.2. Métodos de Diseño Para describir el funcionamiento de un circuito digital, VHDL puede ser usado para diseñar de tres maneras distintas: Diseño Estructural Diseño de flujo de datos Diseño de Comportamiento

Es importante aclarar que aunque estos tres métodos son completamente diferenciables, en un diseño complejo pueden utilizarse todas las formas mencionadas, lo que permite una implementación integral que cumpla las especificaciones requeridas del circuito.

1.5.2.1. Diseño Estructural Al igual que un programa tradicional, el diseño puede ser más entendible y eficiente si este se divide en un conjunto de bloques que cumplen una función específica. Dichos bloques pueden interconectarse entre sí formando un diseño completo.

55

Un diseño VHDL puede describirse como un bloque sencillo o como función de una gran cantidad de ellos. Cada bloque se denomina Entidad. Para que una entidad sea reconocida en el espacio global del diseño, debe poseer por si misma un conjunto de parámetros de interfaz (señales entrada / salida) y un conjunto de elementos que indiquen la funcionalidad del bloque. Una vez se tienen definidas las entidades básicas, se pueden utilizar dentro de otras formando un diseño completamente estructurado. Cuando la entidad E necesita dentro de su diseño la entidad X, se dice que X es componente de la entidad E. Cuando la entidad E asigna señales para ser usadas en X (en la descripción 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 señales 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. Diseño por Flujo de Datos Este diseño indica como las entradas y las salidas de componentes primitivos (ej. la compuerta and) están interconectados. Es decir, describe la forma en que las señales fluyen a través del circuito. Debe notarse que en un diseño estructural, el componente más elemental, puede estar descrito por medio del flujo de señales. En el diseño por flujo de datos o señales, se utilizan comandos concurrentes.

1.5.2.3. Diseño de Comportamiento El diseño por comportamiento difiere de los anteriores ya que no se necesita reflejar como es la implementación del circuito. Unicamente se define su comportamiento. Este tipo de diseño 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 diseño por métodos anteriores (interconexiones e implementación) y por último, el diseño por comportamiento es similar a la programación 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. Aproximación al Diseño Estructural En el proyecto que se realiza se utiliza el diseño estructural para implementar el diseño circuito deseado por el usuario. En esta sección se explican los diversos conceptos que se involucran en el diseño estructural, así como la sintaxis y las palabras reservadas de VHDL necesarias para la representación válida de un circuito.

56

Como se menciona con anterioridad, el lenguaje VHDL es bastante complejo, y los comandos que se presentan en esta sección son solo una pequeña parte de este complejo y eficiente lenguaje. Dichos comandos son los que se utilizan en el proyecto realizado. NOTA: Se usarán en mayúsculas y en negrilla las palabras reservadas de VHDL. Este lenguaje no es sensitivo a minúsculas o mayúsculas.

1.5.3.1. Definición de Bloques El concepto de programación estructurada en los lenguajes convencionales es similar al que se plantea en el diseño estructural de VHDL. Un diseño complejo puede ser dividido en diversas unidades que son conectadas jerárquicamente. Cada una de esas unidades se denominan Bloques. Sin embargo, un diseño 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á diseñando es un circuito sumador simple, se necesitan dos entradas y dos señales de salida. Esto debe reflejarse dentro del grupo ENTIDAD. El siguiente es un ejemplo de la declaración 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 básicos de la declaración de una entidad:

ENTITY – IS

Indican a VHDL el comienzo de la declaración de la entidad circuito_sumador.

PORT Esta cláusula define la interfaz del bloque, compuesta por una o más señales que pueden ser entradas (IN), salidas (OUT) o bidireccionales (INOUT). Cada señal corresponde a un tipo de dato. (En el ejemplo es un vector denominado

57

STD_LOGIC_VECTOR) END Define el fin de la declaración de la entidad

Tabla 21 Elementos básicos de la declaración de una entidad

1.5.3.3 Tipos De Señales Como en cualquier lenguaje de programación, en VHDL existen una gran cantidad de tipos de datos. El tipo más 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 núcleo de VHDL, pero sí hacen parte del estándar IEEE. STD_LOGIC STD_LOGIC_VECTOR

Para que estos tipos sean reconocidos por VHDL, deben utlizarse dos comandos que permiten incluir una librería estándar 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 librerías encapsuladas. USE indica el uso de la librería IEEE.std_logic_1164 y ALL permite que toda la librería sea compilada. 1. TIPO STD_LOGIC Este tipo de dato encapsula el comportamiento de un bit, con sus dos posibles valores 0 ó 1. Además, puede indicar un valor de Alta Impedancia, o Valor Sin Importancia. Los valores de este tipo de dato son:

'U' Sin inicializar 'X' Forzado '0' Valor lógico 0. '1' Valor lógico 1 'Z' Impedancia Alta 'W' Débil desconocido 'L' Débil 0 'H' Débil 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 cláusula:

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 válida de declarar el vector es:

STD_LOGIC_VECTOR (0 TO 1); La primera expresión es la mas usada, ya que representa fielmente una cadena de bits, donde los valores más significativos se corresponden a índices mayores. Los tipos presentados anteriormente corresponden a señales que sirven de interfaces de entrada/salida, sin embargo, VHDL provee el comando SIGNAL que indica al compilador señales internas, que pueden usarse temporalmente dentro del diseño.

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 declaración 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 básicos de la declaración de una arquitectura:

ARQUITECURE – OF- IS Indica a VHDL el comienzo de la cláusula del comportamiento de una entidad

BEGIN Palabra que señala el comienzo de la descripción del comportamiento. Entre ARQUITECTURE y BEGIN pueden implementarse otras cláusulas que se verán en la siguiente sección

<= Operador de Asignación ; Marca el fin de una sentencia

Tabla 23 Elementos básicos de la declaración de una arquitectura

59

En el ejemplo anterior se pueden hallar varios temas importantes: Asignación de señales.

Se realizan por medio del operador <=, y equivale a la asignación de los lenguajes convencionales La diferencia radica en que este operador indica ante todo una transferencia de señales más que de valores. En VHDL existe el concepto de Variable y Constante, donde la asignación 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 diseño concurrente),se pueden utilizar como en cualquier lenguaje de programación operadores lógicos, operadores relacionales, operadores aritméticos, operadores para el manejo de bits. Así mismo existen cláusulas condicionales. Existen sentencias para el uso de ciclos, pero se debe hacer dentro de una cláusula PROCESS que define un diseño secuencial. En el trabajo que se presenta, se utilizan ante todo operadores lógicos y una sentencia condicional conocida como WITH-SELECT

1.5.3.4.1. Operadores Lógicos Los siguientes son los operadores lógicos que se pueden utilizar en VHDL: 1. AND 2. OR 3. NOT 4. XOR 5. NAND 6. NOR 7. XNOR En el capítulo Circuitos Lógicos Combinatorios se detallan la mayoría de estas funciones.

1.5.3.4.2. Sentencia With-Select La estructura de WITH-SELECT se describe a continuación:

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 señal Salida diferente para un conjunto (o subconjunto) de valores de la señal Entrada. Se asemeja al comando SWITCH-CASE del lenguaje C (A decir verdad, dentro de la cláusula PROCESS, puede usarse una sentencia CASE que tiene una función 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 continuación se muestra el código 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 Salida 1 Salida 0 0 0 0 0 0 1 0 1 1 0 0 1 1 1 1 0

Tabla 24 Comportamiento del circuito circuito_sumador Ahora supóngase que se tiene otro bloque denominado mi_and, que simplemente recibe como señales de entrada dos bits, y retorna la operación AND en una señal de salida. El código 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 STD_LOGIC_VECTOR (1 DOWNTO 0); Salida_mi_and: OUT STD_LOGIC

); END mi_and; 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 función predefinida AND de VHDL y utilizar mi_and. Para conectar bloques, VHDL permite el uso de componentes e instancias. La cláusula COMPONENT (componente) es usada para definir la interfaz con el bloque que será utilizado, lo que se denomina en términos de diseño, el bloque de nivel inferior (down level). Así, dentro de la definición del comportamiento (ARQUITECTURE) de circuito_sumador se puede usar la cláusula 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 cláusula 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 líneas 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 cláusula PORT MAP especifica como es la relación de las señales 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 diseño. Debe comentarse que aunque parece inoficioso utilizar todo un bloque lógico para realizar una operación sencilla como la compuerta AND (que hace parte de los operadores lógicos predefinidos del núcleo de VHDL) , la explicación anterior puede extenderse a bloques más complejos que pueden verse como cajas negras en el momento del diseño. De esta forma. el diseño circuito completo es el siguiente: LIBRARY IEEE; USE IEEE.std_logic_1164.ALL; ENTITY mi_and IS PORT ( Entrada_mi_and: IN STD_LOGIC_VECTOR (1 DOWNTO 0); Salida_mi_and: OUT STD_LOGIC

); END mi_and; 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 Básicos Un dispositivo lógico programable es un dispositivo en el cual la descripción lógica de un circuito puede ser modificada o almacenada a través de programación.

Figura 19 Estructura de un CPLD.

El dispositivo más común 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 pequeñas celdas lógicas (bloques funcionales –BF-), las cuales pueden ser interconectadas entre sí de acuerdo al programa establecido para el circuito. Una gran cantidad de compañías 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 lógicos que pueden ser encadenados para formar una implementación lógica de un circuito complejo. Existen dos tipos de FPGAs Grano Fino

Aquel que se encuentra elaborado por una gran cantidad de compuertas, transistores o pequeñas celdas lógicas. Grano Grueso

Consta de celdas lógicas complejas, que a su vez son hechas de un conjunto de flip-flops y Tablas de Búsqueda (Look up Tables –LUT-), las cuales pueden generar funciones lógicas 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 tamaño y su bajo costo. Basada en Static Ram

Las celdas SRAM son implementadas como funciones generadoras para simular la lógica combinatoria, y además controlan los multiplexores y los recursos de enrutamiento. Actualmente son las más populares. 1.6.2. FPGA Serie XC4000 Actualmente se cuenta en la Universidad Nacional de Colombia (sede Bogotá) con un dispositivo lógico reprogramable FPGA del tipo XC4000. Sobre este dispositivo se realiza la simulación del circuito sumador. La presente sección pretende describir las características principales de este elemento. Este dispositivo es fabricado por la empresa Xilinx Inc. Los datos presentados a continuación (figuras, esquemas y especificaciones técnicas) fueron suministrados por dicha compañía.

65

1.6.2.1. Descripción Un dispositivo de la serie XC4000, consta de un conjunto de Bloques Lógicos Configurables (Configurable Logic Block –CLB-), interconectados de diversas maneras dentro de un perímetro definido por Bloques de Entrada/Salida programables (Input/Output Block – IOB-). Los dispositivos se programan leyendo la configuración proveniente de un archivo de datos y registrándola en celdas de memoria. Estos dispositivos son reprogramables, lo que implica que pueden ser usados para la implementación de diseños donde el hardware es cambiado de forma dinámica, 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 especificación.

Figura 20 Estructura de un FPGA.

1.6.2.2. Componentes Básicos Los siguientes son los elementos básicos de un dispositivo FPGA de la familia XC4000.

1.6.2.2.1 Bloques Lógicos Configurables La mayor parte de la lógica que puede ser implementada en un FPGA, se hace dentro de los Bloques Lógicos 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 función booleana de 4 entradas. Se implementan por medio de tablas de búsqueda. Una gran cantidad de funciones lógicas 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 Lógico.

Un CLB puede ser usado para implementar cualquiera de las siguientes funciones: Cualquier función de hasta 4 variables, mas una segunda función de 4 variables no

relacionadas, y cualquier función de 3 variables no relacionadas. Cualquier función de 5 variables. Cualquier función de 4 variables con algunas funciones de seis variables. Algunas funciones de hasta 9 variables.

Un Bloque Lógico Configurable consta además de los siguientes elementos: Flip-Flops: Permiten el paso de señales dentro del bloque, así como almacenan los resultados

combinacionales. Se disparan por medio de una entrada de reloj común. Señales 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 lógica interna implementada y el ambiente externo. Cada IOB controla un pin de la tarjeta y puede ser configurado para señales 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 señales hacia las líneas de conexión que se encuentran rodeando al CLB. Pueden ser usados además para la programación de buses.

1.6.2.2.4. Interconexiones Todas las conexiones internas se componen de segmentos metálicos con cruces y matrices programables que permiten diseñar diferentes rutas. Existen tres tipos de interconexión que son: Enrutamiento del CLB asociado con cada fila y columna del arreglo de CLBs. Enrutamiento del IOB alrededor de la matriz de CLBs. Conexión de los recursos

Entrada/Salida con los bloques de lógica interna. Enrutamiento global que consta de redes dedicadas a la distribución de pulsos de reloj a

través del dispositivo con un mínimo de demora.

1.6.2.3. Reconfiguración del FPGA Existen dos tipos de reconfiguración en estos dispositivos: Estática y Dinámica. Figura de fotocopia.

68

1.6.2.3.1. Reconfiguración Estática Es la que se lleva a cabo en tiempo de compilación. El dispositivo lee un paquete de datos de programa mientras el sistema no se encuentra actualmente operando. Ya que el tiempo de reconfiguración puede ser ignorado, la reconfiguración de un circuito es simple.

1.6.2.3.2. Reconfiguración Dinámica En este tipo de reconfiguración, el dispositivo puede modificar el contenido lógico sin perturbar la operación del sistema. En un dispositivo FPGA de la familia XC4000 se debe reconfigurar todo el circuito, mientras que en series más complejas, como el caso de XC6200, se pueden modificar solo algunas partes del diseño.

1.6.2.4. Programación del FPGA La reconfiguración del FPGA se hace básicamente por medio de la lectura de un paquete de datos que indica las características que el dispositivo debe tener. Para llegar a esta configuración se deben seguir los siguientes pasos básicos: 1. Captura del Diseño. 2. Implementación del Diseño. 3. Verificación 4. Configuración.

1.6.2.4.1. Captura del Diseño La descripción del circuito que debe ser implementado en el FPGA puede realizarse por medio de herramientas CAD, donde se realizan diseños esquemáticos. Además existen niveles de alto nivel para la descripción de Hardware (Hardware Description Language –HDL-) que pueden combinarse con el diseño esquemático. La mayoría de herramientas CAD poseen interfaces con distintos vendedores, entre ellos Xilinx. En la siguiente figura se encuentra el diseño de un cronómetro digital que se implementa en un circuito Xilinx.

69

Figura 23 Captura del diseño en FOUNDATION de XILINX.

1.6.2.4.2. Implementación del Diseño Después de la captura del diseño para un circuito FPGA de la familia Xilinx, se convierte a un formato XNF (Xilinx Netlist Format) o a un formato estándar EDIF. La figura 24 es el código XNF de un diseño capturado en FOUNDATION SERIES de Xilinx. El software de Xilinx se encarga de particionar el diseño en bloques, luego analiza el lugar correspondiente de cada bloque para obtener un rendimiento óptimo, y por último selecciona las rutinas de interconexión. Este proceso ocurre automáticamente, pero el usuario puede modificarlo especificando puntos críticos 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 interconexión, 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 código XNF de un diseño capturado en FOUNDATION SERIES de Xilinx.

1.6.2.4.3. Verificación del Diseño La verificación del diseño se logra por medio de la creación de señales estímulo al circuito implementado. La gran mayoría de herramientas proveen funciones para la verificación y simulación de circuitos de forma funcional y por tiempos.

1.6.2.4.4. Configuración La configuración es el proceso por el cual el diseño del circuito (archivo bitstream) se carga en el dispositivo lógico reprogramable. El software utilizado para la carga del FPGA permite al usuario modificar el tipo de configuración que se llevará a cabo. Puede configurarse de dos formas dependiendo del tamaño de los datos: Configuración Serial (Bits): Usa una PROM serial. Configuración Paralela (Bytes): Por medio de PROM estándar o un multiprocesador.

71

2. ANALISIS Y DISEÑO DEL PROBLEMA

2.1. METODOLOGIA La metodología que se aplico para las fases de análisis y diseño del problema, combina la ingeniería de software tradicional[4] con el ciclo de vida propuesto en el documento de G. Mañana[5] (Ver Anexos).

2.2. ANALISIS DEL PROBLEMA PARA EL DESARROLLO DEL MODELO 2.2.1. Análisis Preliminar Dentro de este proceso se requiere una descomposición funcional del sistema analizando los procesos que componen la aplicación, en este caso el sistema general abarca desde la entrada de datos requeridos por el algoritmo de programación genética, el cual da como resultado un programa generado tipo LISP que es capaz de resolver un problema (encontrar la estructura de un circuito lógico combinatorio). 2.2.2. Especificación de Requerimientos Un simulador de Programación genética para el diseño de circuitos combinatorios, es una aplicación gráfica 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 programación genética, definiendo un conjunto de parámetros como son: probabilidad de cruce, mutación, señales de entrada, señales constantes, función de usuario, función básica, número de generaciones, tipo de selección, tipo de aptitud, y número de niveles de la población inicial. Además de ésta información, el usuario puede seleccionar las funciones a utilizar en la ejecución del algoritmo, ya sean propias (AND, OR, NOT, XOR) o creadas por él mismo (con el mismo formato del circuito buscado, excepto que toda función debe cumplir con el requisito de tener solamente una salida). El usuario tiene como herramientas menús con todas las funciones y botones rápidos para las más usadas. Los procedimientos que seguirá el usuario son los siguientes: Leer el archivo de tabla de verdad del circuito buscado. Ingresar por teclado, los parámetros de configuración del algoritmo genético. Seleccionar funciones creadas por el mismo. Ejecutar el algoritmo de programación genética.

72

Salvar el resultado del algoritmo, como un archivo de VHDL, una sentencia tipo LISP, además de las estadísticas de ejecución del algoritmo.

Restricciones: ✗ El simulador no tendrá múltiple documento, será SDI. ✗ Solo operará bajo entorno Windows. El siguiente diagrama (Figura 25) de E/S muestra el comportamiento básico esperado de la aplicación:

.Representación Gráficay VHDL de la Solución

Programa con sintaxisLISP que resuelve elCircuito buscado

Algoritmo de Programación

Genética Datos propios paraproblemas deProgramación Genética

Datos propios delcircuito buscado

Figura 25 Diagrama de Flujo de datos de la Aplicación.

2.2.2.1 Entradas El programa permite al usuario proporcionar los valores de ejecución típicas del algoritmo como son: las probabilidades de cruce y mutación, el tamaño de la población, el número de individuos por generación, tipo de selección, probabilidad de funciones o terminales y constantes, esto con el fin de que sea flexible y permita observar el comportamiento del algoritmo según la variación de dichos parámetros. Además, el usuario debe ingresar la tabla de verdad del circuito que desea buscar, con el número de salidas y entradas del mismo. El usuario puede almacenar los parámetros utilizados en forma de proyecto, con lo cual puede utilizar la configuración establecida para pruebas posteriores.

2.2.2.2. Algoritmo de Programación Genética La ejecución del algoritmo de programación genética propiamente dicho tiene como base todas las operaciones genéticas descritas anteriormente (selección, cruce y mutación). La función objetivo empleada se encarga de la ejecución del árbol, con los datos de entrada de las 2n combinaciones posibles de entradas, para luego comparar el resultado de la ejecución con las salidas correspondientes esperadas para la combinación 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 máxima de un individuo será de la cantidad de combinaciones por el número de salidas, 8x2=16. La estructura de datos básica para el almacenamiento de los programas generados es de árbol binario de profundidad inicial máxima constante, y durante el proceso, se trabaja con una profundidad máxima 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 número 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 generación no se modifique demasiado. - El mejor individuo es hallado antes de cumplir el número de generaciones establecido

inicialmente

2.2.2.3. Salidas Se tienen como salidas: 1. La traducción del árbol generado en términos de llamadas a las funciones propias del

problema implementadas en LISP. 2. La traducción del árbol en lenguaje VHDL, con el fin de permitir la implementación física del

circuito. 3. Archivos de estadísticas.

2.3. DISEÑO DE LA APLICACION. 2.3.1. Descomposición Funcional Siguiendo el modelo de análisis del problema se plantea el siguiente diagrama básico de representación funcional (Figura 26):

21 3. Presentación de la solución al circuito buscado.

2. Construcción yEjecución del Algoritmo deProgramación Genética.

1. Ingresode datos porteclado

Figura 26 Diagrama de Representación Funcional de la Aplicación. 1. Ingreso de datos por teclado Responsable: Usuario Descripción: Los datos que requiere el programa para funcionar son proporcionados por el usuario, estos se refieren principalmente a: Parámetros propios del algoritmo como la probabilidad de cruce y mutación, el número de 74

individuos, el tamaño de la población, el número de generaciones y el tamaño máximo de los árboles, etc. 2. Construcción y ejecución del algoritmo de programación genética Responsable: Algoritmo de programación genética. Descripción: Dado que se adopta la visión propuesta por Koza según la cual, la representación más conveniente para la programación genética es la de árboles[3]. La construcción de la población 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 tamaño de los árbol no sobrepase los límites establecidos por el usuario. Además se encarga de la ejecución del algoritmo genético con los parámetros establecidos por el usuario. 3. Presentación de la solución del circuito buscado. Responsable: Interfaz de usuario. Descripción: Una vez haya sido evaluado e interpretado el mejor árbol de la población, la interfaz se encarga de presentar la solución al usuario en forma de código LISP y de lenguaje VHDL. 2.3.2. Flujo de Datos Los puntos de flujo de información dentro de la aplicación están representados en la Figura 20, como las flechas de unión de los bloques de la descomposición funcional, y son: 1. Datos relevantes proporcionados por el usuario son transmitidos al modulo de construcción y

ejecución del algoritmo de programación genética, de modo que la población inicial pueda ser creada para dar comienzo a la ejecución del algoritmo.

2. El árbol marcado como mejor individuo de la población, luego de la ejecución del algoritmo

de programación genética con los parámetros iniciales dados por el usuario es transferido a la interfaz de usuario con el propósito de presentar la solución a éste de manera comprensible.

Del análisis anterior se puede llegar a la definición de los módulos principales de la aplicación y el flujo de datos entre ellos (Figura 27).

75

Manipulación de la Estructurade los Arboles

Evaluación dela Aptitud de losÁrboles

5. Intérprete de Resultados

4. Ejecución delAlgoritmo deProgramación Genética

3. Manipulador de lasestructuras de datos enárbol

Algoritmo de Programación Genética

Programa Resultado

Parámetros de Ejecución

2. Presentación deresultados

1. Entrada de Datos

Interfaz Con el Usuario

Figura 27 Descomposición por módulos de la aplicación. 2.3.3. Definición de la Estructura LISP (Arboles) y Consideraciones Iniciales del Problema Como se observo en el capitulo referente a la programación genética, todos los individuos deben tener una estructura sintácticamente correcta, es por esto que para facilidad de ejecución y funcionamiento, se aplicará al árbol una sintaxis similar a la utilizada en LISP, con las siguientes características:

2.3.3.1. La Raíz Para la raíz del árbol, se ha definido la función CONCAT, la cual retorna una cadena de bits, que representa la salida de cada rama hijo de la función, por ejemplo, si el circuito buscado tiene 3 (tres) salidas, así será la cantidad de hijos de la función CONCAT, y ella retornara al ejecutar el árbol con un conjunto de entradas determinadas una cadena de 3 bits, es denotar que esta función solo será usada en la raíz del árbol. Esta función 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 función de una entrada NOT. Ninguna de ellas estará en la raíz del árbol. El usuario podrá definir otras funciones, con la restricción de que estas solamente tendrán un bit de salida, y un número variable de entradas limitado.

76

2.3.3.3. Las Terminales Corresponden al número de entradas definidas inicialmente para el circuito buscado, y se corresponden con las letras del alfabeto, desde la A hasta la Z. Además, se permite el uso de las señales constantes 1 y 0.

2.3.3.4. Ejemplo El árbol representado en la figura 28, es según la descripción hecha anteriormente, un circuito sumador completo de 2 bits, con entradas A, B y salidas S (Suma) y C (Carry), la representación del circuito en diagrama lógico se puede ver en la misma figura.

Figura 28 Representación lógica y de árbol de un circuito sumador completo de 2 bits, cuya

representación 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á señalando las frases nominales de la Especificación de Requerimientos, obteniendo una lista preliminar, en ella aparecerán 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 Programación genética para el diseño de circuitos combinatorios, es una aplicación gráfica 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 programación genética, definiendo un conjunto de parámetros como son: probabilidad de cruce, mutación, señales de entrada, señales constantes, función de usuario, función básica, número de generaciones, tipo de selección, tipo de aptitud, y número de niveles de la población inicial. Además de ésta información, el usuario puede seleccionar las funciones a utilizar en la ejecución 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 función debe cumplir con el requisito de tener solamente una salida). El usuario tiene como herramientas menús con todas las funciones y botones rápidos para las más usadas. Los procedimientos que seguirá el usuario son los siguientes: ✏ Leer el archivo de tabla de verdad del circuito buscado. ✏ Ingresar por teclado, los parámetros de configuración del algoritmo genético. ✏ Seleccionar funciones creadas por el mismo (también manejadas por archivo, herramienta de

creación de tablas). ✏ Ejecutar el algoritmo de programación genética. ✏ Salvar el resultado del algoritmo, como un archivo de VHDL, una sentencia tipo LISP,

además de las estadísticas de ejecución del algoritmo. ✏ Reiniciar el proceso con los individuos resultantes al terminar el proceso. Con esta primera inspección llegamos a la siguiente lista de posibles clases:

Simulador de Programación Genética Aplicación Aplicación gráfica interactiva Aplicación Circuitos combinatorios Clase primaria. Tabla de verdad Manipula las tablas de circuitos y

funciones (Manejador de Archivos) Entradas Atributo Salidas Atributo Parámetros Atributo Algoritmo genético Instancia del objeto GASteadyState

de la librería GALib(Ver anexos). Terminales(Entradas o Constantes) De señales usadas por el circuito. Funciones definidas por el usuario Características y orden Menús Modelado por Windows Herramienta de creación de tablas Aplicación auxiliar Botones Modelado por Windows Archivo de VHDL Método Sentencia tipo LISP Método Individuos Instancias de los objetos

GATreeGenome agrupados en la instancia de GAPopulation de la librería GALib(Ver anexos).

Estadísticas Atributo

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 aplicación. Sennal: Encargado de la representación de una señal, constante (1 ó 0)o de entrada al circuito [A...Z]. TNodo: Representa un nodo de un individuo(árbol) función o terminal. TCircuito: interfaz del algoritmo genético con la aplicación principal. TEvalua: Se encarga de evaluar, recorrer y generar el código VHDL o LISP de cualquier árbol sintácticamente correcto. Función_usuario: Representación de una función definida por el usuario. Patron: Representa una tabla de verdad, ya sea de una función definida por el usuario o la de un circuito buscado. THilo: Thread que manipula la ejecución del algoritmo genético permitiendo al usuario mantener el control de la aplicación. TVariables: Generador de variables para el código VHDL. TFormaArbol: Manipula el conjunto de las funciones activas tanto básicas como de usuario.

2.3.4.3. Registro De Clases En las tarjetas presentadas a continuación se registran las clases con los siguientes datos: Nombre. Tipo de clase: Concreta (C ) o Abstracta (A), según el fin con el cual fueron creadas, es decir, si se crean para agrupar atributos y comportamientos comunes a un conjunto de subclases, serán Abstractas; pero si tienen el fin de crear objetos a partir de ellas y definir los métodos especificados en una clase abstracta, serán 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 propósito de la clase dentro de la aplicación.

79

Recibe los parámetros necesarios para la resolución del problema, y controla laejecución del programa, para luego presentar en pantalla los resultados del mismo.

Propósito

C Clase: TControles

✓ Editar los objetos que intervienen en lasimulación.

✓ Mostrar la simulación. ✓ Controlar los parámetros de ejecución. ✓ Mostrar los resultados de la simulación.

Clase: TControles Superclase: Subclase: Responsabilidades Colaboraciones

✓ TCircuito: Se encarga de inicializar lasestructuras necesarias para la ejecución delalgoritmo genético.

✓ Funcion_Usuario: Brinda elcomportamiento de una función de usuariopara que él pueda modificar el conjuntoexistente.

✓ THilo: Toma una referencia de TCircuito ycrea la ejecución de un Algoritmo genéticoen un proceso independiente.

✓ TFormaArbol: Guarda la lista de funcionesbásicas y de usuario activas.

C

Colaborar con la interfaz para manipular las funciones activas tanto básicas como deusuario definidas para la ejecución de la simulación.

Propósito

C Clase: TFormaArbol

✓ Mantener actualizada la lista defunciones básicas o de usuario activas.

✓ Presentar la lista de funciones enpantalla.

Clase: TFormaArbol Superclase: Subclase: Responsabilidades Colaboraciones

✓ Funcion_Usuario: Define elcomportamiento de una función de usuariopara que él pueda modificar el conjuntoexistente.

C

80

Definir una señal, de entrada [A..Z] o constante (0,1), generada aleatoriamente o con unvalor dado.

Propósito C Clase: sennal

✓ Definir las terminales de losindividuos(árboles).

Responsabilidades Colaboraciones

C Clase: Sennal Superclase: Subclase:

Identificar una función definida por el usuario, con un nombre y una tabla de verdadque la identifica, según el número de entradas.

Propósito C Clase: Funcion_Usuario

✓ Patron: Define la tabla de verdad de lasfunciones de usuario activas.

✓ Identificar una función creada por elusuario, con número de argumentos,salidas y la tabla de verdadcorrespondiente

✓ Manipulación de los archivoscorrespondientes

Responsabilidades Colaboraciones

C Clase: Funcion_Usuario Superclase: Subclase:

81

Definir y distinguir los nodos componentes de los árboles, en funciones (básicas y deusuario)y terminales (señales de entrada o constantes).

Propósito C Clase: TNodo

✓ Sennal: Permite que el nodo pueda serdefinido como entrada de circuito oseñal constante.

✓ Funcion_Usuario: Permite que el nodosea definido como función del usuario.

✓ Representar un nodo constituyentebásico de los árboles.

✓ Función básica o de usuario o señalconstante

Responsabilidades Colaboraciones

C Clase: TNodo Superclase: Subclase:

Interfaz que define el comportamiento del programa genético con los parámetros dadospor el usuario. Se encarga de la creación de la población inicial de árboles, y de ladefinición de la función objetivo.

Propósito C Clase: TCircuito

✓ TEvalua: Retorna la aptitud de unárbol.

✓ TNodo: Devuelve una referencia a unnodo para ser insertado en un árbol.

✓ GALIB: Da el comportamiento de losindividuos de la población del AG.

✓ Comunicar la Interfaz con el Algoritmogenético

Responsabilidades Colaboraciones

C Clase: TCircuito Superclase: Subclase:

82

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 Código Fuente VHDL correspondiente y salvarlo en un archivo.

Propósito C Clase: TEvalua

✓ TNodo: Retorna el contenido de unnodo de un árbol.

✓ Funcion_Usuario: Define elcomportamiento de una función dada.

✓ GALIB: Define la estructura de unárbol

✓ TVariables: Crea variables auxiliaresque se insertan en el código VHDL.

✓ Sennal: Comportamiento de un nodoterminal

✓ Evaluar un árbol con unas Entradasdeterminadas (Ejecutarlo)

✓ Generar la cadena LISP que loRepresenta

✓ Generar el Código Fuente VHDLcorrespondiente.

ColaboracionesResponsabilidades

C Clase: TEvalua Superclase: Subclase:

Comportarse como un tipo de dato alfabético que representa palabras (nombres devariables auxiliares)

Propósito C Clase: TVariables

✓ Encapsular el comportamiento de unavariable auxiliar para ser usada en lageneración de código VHDL

Responsabilidades Colaboraciones

C Clase: TVariables Superclase: Subclase:

83

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

Propósito C Clase: Patron

✓ Manipular un patrón de entradas ysalidas para una función o un circuito.

Responsabilidades Colaboraciones

C Clase: Patron Superclase: Subclase:

Ejecutar y controlar la ejecución del programa genético.

Propósito C Clase: THilo

✓ TCircuito: Recibe una referencia de lasestructuras necesarias para la ejecucióndel algoritmo.

✓ TEvalua: Retorna la cadena LISP yVHDL asociadas al mejor individuo.

✓ Trasladar la ejecución del programa aun proceso asincrónico (hebra)

Responsabilidades Colaboraciones

C Clase: THilo Superclase: Subclase:

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 prestación de colaboración al objeto que la recibe.

Figura 29 Diagrama de Colaboraciones Entre Objetos.

2.3.5. Diagrama De Transición De Estados En el análisis de una aplicación se hace necesario recorrerla por diferentes caminos (walk-through): imaginar cómo se invoca un servicio, ver que responsabilidades están implicadas en cada uno de ellos y analizar todos los servicios que pueda prestar éste; es entonces importante realizar un Diagrama de Transición de Estados (DTE) del Simulador (Figura 30). En dicho diagrama se utilizarán las siguientes convenciones para los estados: (1) Leer tabla de verdad de circuito a buscar. (2) Leer parámetros del algoritmo. (3) Leer y configurar funciones básicas y del usuario. (4) Ejecutar el algoritmo de programación genética. (5) Generar código LISP, VHDL y Estadísticas de la última corrida. (6) Guardar Archivos (LISP, VHDL, estadísticas).

85

Figura 30 Diagrama de Transición de Estados.

2.3.5.1. Descripción de las Transiciones 1-2,3: Luego de definir la tabla de verdad del circuito buscado, pueden modificarse tanto los parámetros del algoritmo como las funciones que se utilizaran en su ejecución. 1-4: Luego de definir la tabla de verdad del circuito buscado, puede ejecutarse directamente el algoritmo con los parámetros predefinidos inicialmente. 2,3-1: Puede luego de configurarse los parámetros, cambiar la tabla del circuito buscado, por otro. 2,3-4: Paso de todos los parámetros para iniciar la ejecución del algoritmo. 4-4: Ejecutar nuevamente el algoritmo (con la población actual o generando una nueva). 4-5: Mostrar los resultados de la programación genética (código VHDL, LISP y estadísticas de la última corrida). 5-4: Ejecutar nuevamente el algoritmo (con la población actual o generando una nueva). 5-6: Guardar en archivos el código VHDL, LISP y las estadísticas. 6-1: Leer una nueva tabla de verdad para buscar otro circuito. 6-2,3: Cambiar los parámetros del algoritmo genético para buscar el circuito actual. 6-4: Ejecutar nuevamente el algoritmo (con la población actual o generando una nueva).

2.4. IMPLEMENTACION 2.4.1. Herramientas de Desarrollo La aplicación, 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 programación C++, basada en la filosofía RAD (rapid application development). Utiliza un framework escrito en ObjectPascal, diseñado alrededor del concepto de propiedades, eventos y métodos, llamado VCL (visual component library). Los objetos de la VCL constituyen una especie de programación visual, ya que al crear la aplicación, estos pueden ser arrastrados hasta alguna forma, generando de manera automática el código asociado a ellos. Cada aplicación, está asociada a un proyecto, el cual contiene formas (archivos .dfm) y unidades, las cuales están compuestas por un archivo de cabecera (.h) y su correspondiente archivo de implementación (.cpp). 86

2.4.2. Herramientas Adicionales

2.4.2.1. GALIB Es una librería de componentes de algoritmos genéticos, desarrollada por el MIT (Massachusetts Institute of Technology, 1995), versión 2.4. implementada en C++ (Ver Anexos). GAlib contiene un conjunto de objetos de algoritmos genéticos en C++. La librería incluye además herramientas para el uso de algoritmos genéticos para efectuar optimizaciones en cualquier programa C++ que use representación y operadores genéticos. En la aplicación realizada, se usa un cruce en un solo punto y mutación de sub-arboles definidas en esta librería.

2.4.2.2. Xilinx Foundation Software Es una herramienta que permite el diseño, simulación, implementación y verificación de circuitos lógicos programables(Ver Anexos), desarrollada por Xilinx Inc.

2.4.2.3. RANDOMLIB Aunque GALIB provee una gran cantidad de algoritmos para la generación de números aleatorios, en este proyecto se usa una pequeña librería denominada RANDOMLIB. El generador esta basado en un algoritmo publicado originalmente en el libro “Toward a Universal Random Number Generator", diseñado por George Marsaglia y Arif Zaman. Se utiliza este algoritmo en la versión final de SimEHDL, ya que durante las pruebas realizadas demostró un mejor desempeño con problemas complejos. 2.4.3. Modulo Tablas de Verdad Éste módulo independiente, no interactua directamente con el simulador, y su tarea básica consiste en la edición de archivos que almacenen la tabla de verdad ya sea de un circuito o de una función definida por el usuario. Este módulo es entonces una aplicación independiente a la que se aplicará el mismo proceso de diseño y análisis que se llevo a cabo con el simulador.

2.4.3.1. Especificación de Requerimientos El módulo tablas es una aplicación gráfica 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 manipulación. 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 aplicación:

Módulo Aplicación Aplicación Gráfica Aplicación Tabla de Verdad Editor Entradas Atributo Salidas Atributo Archivo Método

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 características de las tarjetas de clases, son las mismas que las descritas para el simulador:

88

Dar forma al programa principal y a los eventos de el mismo.

Propósito C Clase: FrameForm

✓ MDIEdit: Configura y pasa referenciasa una tabla de verdad.

✓ Contener los archivos de tablas deverdad.

✓ Soportar la aplicación.

Responsabilidades Colaboraciones

C Clase: FrameForm Superclase: Subclase:

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

Propósito C Clase: Patron

✓ Manipular un patrón de entradas ysalidas para una función o un circuito.

Responsabilidades Colaboraciones

C Clase: Patron Superclase: Subclase:

89

Manipular una tabla de verdad.

Propósito C Clase: MDIEdit

✓ Configura: Configura y pasa validaciónrespecto a número de entradas y salidas dela tabla de verdad.

✓ Patron: Identifica una tabla de verdad.

✓ Encapsular el comportamiento de unatabla de verdad.

✓ Manipular el archivo asociado a lamisma.

ColaboracionesResponsabilidades

C Clase: MDIEdit Superclase: Subclase:

Validar el ingreso de datos para la creación de una tabla de verdad (número de entradas

y salidas).

Propósito A Clase: Configura

✓ Validar el ingreso de datos para la

creación de una tabla de verdad

(número de entradas y salidas).

Responsabilidades Colaboraciones

A Clase: Configura Superclase: Subclase:

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 prestación de colaboración al objeto que la recibe.

Figura 31 Colaboraciones entre objetos del módulo Editor de tablas.

2.4.4. Diagrama de Transición de Estados El Diagrama de Transición de Estados (DTE) del Módulo Editor de Tablas (Figura 32). En dicho diagrama se utilizarán las siguientes convenciones para los estados: (1) Abrir Nueva Tabla de Verdad. (2) Abrir Tabla de Verdad existente. (3) Leer parámetros de creación de Tabla de Verdad. (4) Editar Tabla de verdad. (5) Grabar en un archivo la Tabla de Verdad actual.

Figura 32 Diagrama de Transición de Estados.

2.4.4.1. Descripción de las Transiciones 1,3: Efectúa una llamada a la lectura de parámetros para la creación de una nueva tabla de verdad. 3,4: Envía los parámetros a un formato de tabla de verdad con las características especificadas.

914,5: Envía los datos modificados a un archivo de Tabla de Verdad.

2,4: Envía 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 aplicación, 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 genético un total de veinte (20) veces con cada uno de los parámetros 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 posición previa menos significativa. Se necesitan dos salidas porque la suma aritmética de tres dígitos binarios varia en valor de 0 a 3 y los binarios 2 ó 3 necesitan dos dígitos las 2 salidas se designan por los símbolos S para la suma y C para el bit de arrastre; la tabla de verdad del sumador completo es como sigue a continuación.

X Y Z S C 0 0 0 0 0 0 0 1 1 0 0 1 0 1 0 0 1 1 0 1 1 0 0 1 0 1 0 1 0 1 1 1 0 0 1 1 1 1 1 1

Tabla 27 Tabla de verdad del sumador completo de 3 bits Para la ejecución del algoritmo se definió la siguiente configuración sin uso de funciones del usuario: Todas las funciones básicas se encuentran activas. No hay funciones de usuario. Número de niveles para la población inicial: cinco (5). Número de individuos: cien (100). Porcentaje función – terminal 80%. Porcentaje entrada - constante 100%. Terminación por perfección. Tipo de selección: mejor individuo. Tipo de aptitud: bits correctos. Cruce : 0.98

93

Mutación : 0.02 Máximo de nivel de castigo: 4. Castigo: 0.05. Porcentaje de intercambio: 0.25

La ejecución del algoritmo arroja los siguientes datos: Peor aptitud total: Es la aptitud del peor individuo durante toda la ejecución del algoritmo (la

mas cercana a 0). Mejor Aptitud Total: Es la aptitud del mejor individuo durante toda la ejecución del

problema. Promedio Aptitud Inicial: Es el promedio de aptitud de la población inicial generada por el

algoritmo. Mejor Aptitud Inicial: Es la aptitud del mejor individuo de la población inicial generada por

el algoritmo. Peor Aptitud Inicial: Es la aptitud del peor individuo de la población inicial generada por el

algoritmo. Promedio Aptitud Total: Es el promedio de aptitudes de todos los individuos procesados

durante la ejecución del algoritmo. Promedio Mejores Aptitudes: Es el promedio de las aptitudes de los mejores individuos de

cada generación durante la ejecución del algoritmo. Número Cruces: Número de operaciones de cruce realizadas durante la ejecución del

algoritmo. Número Mutaciones: Número de operaciones de mutación realizadas durante la ejecución del

algoritmo. Número Selecciones: Número de operaciones de selección realizadas durante la ejecución del

algoritmo. Número Generaciones Necesarias: Número de generaciones necesarias para encontrar al

mejor individuo (aptitud = 1) , durante la ejecución del algoritmo. Tiempo Total en Segundos: Tiempo total en segundos requerido para encontrar al mejor

individuo, durante la ejecución 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 Promedio Peor Aptitud Total 0,25625 Mejor Aptitud Total 1 Promedio Aptitud Inicial 0,5749 Mejor Aptitud Inicial 0,75625 Peor Aptitud Inicial 0,25625 Promedio Aptitud Total 0,82599 Promedio Mejores Aptitudes 0,90594 Número Cruces 3282,8 Número Mutaciones 5198,4 Número Selecciones 3351,4 Número Generaciones Necesarias 128,9 Tiempo Total en Segundos 74,9

94

Tabla 28 Resuman del comportamiento para el sumador de 3 bits A continuación se presenta un ejemplo resultante de la ejecución del algoritmo con los parámetros anteriormente mencionados. 3.1.1. Ejemplo Resultante con la Todas las Funciones Básicas 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))) Estadísticas: 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 Número Cruces: 1718 Número Mutaciones: 1152 Número Selecciones: 1742 Número Generaciones Necesarias: 67 Tiempo Total en Segundos: 35 Código 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 -- --Asignación de entradas del circuito A<=Entrada(0); B<=Entrada(1); C<=Entrada(2); --Asignación 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 básicas (para éste caso la compuerta XOR) o las definidas por el usuario, se presenta un resumen de la ejecución del mismo circuito con idénticas características obviando el uso de la función predefinida básica XOR.

Resumen Promedio Peor Aptitud Total 0,3125 Mejor Aptitud Total 0,96875 Promedio Aptitud Inicial 0,52515 Mejor Aptitud Inicial 0,71875 Peor Aptitud Inicial 0,3125 Promedio Aptitud Total 0,8639 Promedio Mejores Aptitudes 0,8944 Número Cruces 15886,5 Número Mutaciones 74551,5 Número Selecciones 16668,5 Número Generaciones Necesarias 537,25 Tiempo Total en Segundos 1864,25

Tabla 29 Resumen del comportamiento sin utilizar la función XOR

96

Luego de comparar la tabla anterior con la tabla correspondiente a el resumen de ejecuciones para el mismo circuito con la función 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 ejecución del circuito sumador completo con la compuerta XOR fue de 74,9 seg. contra los 1864,25 seg. de la ejecución 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(NOT(AND(OR(OR(AND(OR(C)(B))(OR(AND(C)(A))(B)))(B))(B))(OR(OR(A)(C))(A))))(AND(B)(AND(C)(A))))(OR(A)(OR(C)(B)))) Estadísticas: 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 Número Cruces: 20516 Número Mutaciones: 60702 Número Selecciones: 20956 Número Generaciones Necesarias: 403 Tiempo Total en Segundos: 3032 Código 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 -- --Asignación de entradas del circuito A<=Entrada(0); B<=Entrada(1); C<=Entrada(2); --Asignación 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 función de carry y suma para el sumador de tres bits, las funciones básicas son inhabilitadas dando como resultados en mas del 80% de los casos una aptitud de uno.

Resumen Promedio Peor Aptitud Total 0,25 Mejor Aptitud Total 1 Promedio Aptitud Inicial 0,6294 Mejor Aptitud Inicial 1 Peor Aptitud Inicial 0,25 Promedio Aptitud Total 0,65735 Promedio Mejores Aptitudes 1 Número Cruces 59 Número Mutaciones 4 Número Selecciones 34 Número Generaciones Necesarias 3 Tiempo Total en Segundos 17

Tabla 30 Resumen del comportamiento utilizando funciones de usuario

Para este caso se uso un número de individuos igual a 50 y máximo de niveles en 3. Como puede observarse la probabilidad de convergencia es mucho mayor, puesto que la cantidad de individuos usados y el máximo de niveles, limitan el comportamiento del algoritmo a un espacio en el que seguramente se podrá encontrar la solución.

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))) Estadísticas: 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 Número Cruces: 128 Número Mutaciones: 78 100

Número Selecciones: 130 Número Generaciones Necesarias: 5 Tiempo Total en Segundos: 28 Código 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",

101 '0' WHEN "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 Temp_0 : STD_LOGIC_VECTOR(2 DOWNTO 0); SIGNAL Temp_1 : STD_LOGIC_VECTOR(2 DOWNTO 0); SIGNAL Temp_2 : STD_LOGIC_VECTOR(2 DOWNTO 0); SIGNAL Temp_3 : STD_LOGIC_VECTOR(2 DOWNTO 0); SIGNAL Temp_4 : STD_LOGIC_VECTOR(2 DOWNTO 0); SIGNAL Temp_5 : STD_LOGIC_VECTOR(2 DOWNTO 0); SIGNAL Temp_6 : STD_LOGIC_VECTOR(2 DOWNTO 0); BEGIN --

102

--Asignación de entradas del circuito A<=Entrada(0); B<=Entrada(1); C<=Entrada(2); --Asignación 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 elección 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 ejecución del algoritmo fue definida la siguiente configuración: Todas las funciones básicas se encuentran activas. No hay funciones de usuario. Número de niveles para la población inicial cinco (3). Número de individuos cien (100). Porcentaje función – terminal 60%. Porcentaje entrada - constante 100%. Terminación por perfección. Tipo de selección: mejor individuo. Tipo de aptitud: bits correctos. Cruce : 0.98 Mutación : 0.02 Máximo de nivel de castigo: 5. Castigo: 0.05. Porcentaje de intercambio: 0.5

Los resultados obtenidos para veinte (20) ejecuciones fueron:

Resumen Promedio Peor Aptitud Total 0,34375 Mejor Aptitud Total 1 Promedio Aptitud Inicial 0,53854 Mejor Aptitud Inicial 0,75 Peor Aptitud Inicial 0,34375 Promedio Aptitud Total 0, 816862 Promedio Mejores Aptitudes 0,874067 Número Cruces 2421.5 Número Mutaciones 3750.2 Número Selecciones 2556,4 Número Generaciones Necesarias 189 Tiempo Total en Segundos 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)(NOT(E)))))) Estadísticas: 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 Número Cruces: 4542 Número Mutaciones: 4956 Número Selecciones: 4628 Número Generaciones Necesarias: 89 Tiempo Total en Segundos: 287 Código 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 -- --Asignación de entradas del circuito A<=Entrada(0); B<=Entrada(1); C<=Entrada(2); D<=Entrada(3); E<=Entrada(4); --Asignación 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 básica y la función 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(andanotb(andanotb(andanotb(A)(andanotb(C)(C)))(E))(andanotb(andanotb(andanotb(andanotb(andanotb(C)(A))(andanotb(D)(andanotb(E)(E))))(andanotb(andanotb(C)(andanotb(C)(C)))(andanotb(C)(A))))(C))(andanotb(OR(C)(E))(B))))(andanotb(C)(andanotb(C)(E)))))(OR(andanotb(E)(andanotb(andanotb(E)(andanotb(D)(andanotb(andanotb(andanotb(C)(andanotb(D)(A)))(C))(andanotb(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))))) Estadísticas: 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 Número Cruces: 11926 Número Mutaciones: 23854 Número Selecciones: 12168 Número Generaciones Necesarias: 234 Tiempo Total en Segundos: 619 Código 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 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 BT : STD_LOGIC; SIGNAL BU : STD_LOGIC; SIGNAL BV : STD_LOGIC; SIGNAL BW : STD_LOGIC; SIGNAL BX : STD_LOGIC; SIGNAL A : STD_LOGIC; SIGNAL B : STD_LOGIC; SIGNAL C : STD_LOGIC; SIGNAL D : STD_LOGIC; SIGNAL E : STD_LOGIC; COMPONENT andanotb PORT ( Entrada_andanotb : IN STD_LOGIC_VECTOR(1 DOWNTO 0); Salida_andanotb : OUT STD_LOGIC ); END COMPONENT; SIGNAL Temp_0 : STD_LOGIC_VECTOR(1 DOWNTO 0); SIGNAL Temp_1 : STD_LOGIC_VECTOR(1 DOWNTO 0); SIGNAL Temp_2 : STD_LOGIC_VECTOR(1 DOWNTO 0); SIGNAL Temp_3 : STD_LOGIC_VECTOR(1 DOWNTO 0); SIGNAL Temp_4 : STD_LOGIC_VECTOR(1 DOWNTO 0); SIGNAL Temp_5 : STD_LOGIC_VECTOR(1 DOWNTO 0); SIGNAL Temp_6 : STD_LOGIC_VECTOR(1 DOWNTO 0); SIGNAL Temp_7 : STD_LOGIC_VECTOR(1 DOWNTO 0); SIGNAL Temp_8 : STD_LOGIC_VECTOR(1 DOWNTO 0); SIGNAL Temp_9 : STD_LOGIC_VECTOR(1 DOWNTO 0); SIGNAL Temp_10 : STD_LOGIC_VECTOR(1 DOWNTO 0); SIGNAL Temp_11 : STD_LOGIC_VECTOR(1 DOWNTO 0); SIGNAL Temp_12 : STD_LOGIC_VECTOR(1 DOWNTO 0); SIGNAL Temp_13 : STD_LOGIC_VECTOR(1 DOWNTO 0); SIGNAL Temp_14 : STD_LOGIC_VECTOR(1 DOWNTO 0); SIGNAL Temp_15 : STD_LOGIC_VECTOR(1 DOWNTO 0); SIGNAL Temp_16 : STD_LOGIC_VECTOR(1 DOWNTO 0); SIGNAL Temp_17 : STD_LOGIC_VECTOR(1 DOWNTO 0); SIGNAL Temp_18 : STD_LOGIC_VECTOR(1 DOWNTO 0); SIGNAL Temp_19 : 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 -- --Asignación de entradas del circuito A<=Entrada(0); B<=Entrada(1); C<=Entrada(2); D<=Entrada(3); E<=Entrada(4); --Asignación 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 investigación, se planteo inicialmente la simulación de un circuito sumador, que por definición 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 recopilación de información abarco el estudio de circuitos lógicos combinatorios, de la cual se concluyó que la simulación del circuito sumador por medio de árboles(aprovechando el potencial de la programación genética) implicaba la creación y uso de nuevas funciones lógicas como son la compuerta OR y la compuerta NOT; además de la manipulación de señales binarias de entrada y salida. De aquí se desprende entonces que la característica 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 ningún 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 número de salidas del circuito, el número de entradas y las funciones lógicas involucradas; Por tanto si estos datos son variables y se tiene a la vez control sobre ellos, teóricamente cualquier circuito combinatorio podría ser encontrado por la simulación. Es así como en la aplicación final, el número de funciones básicas aumenta, y además el usuario puede crear sus propias funciones, lo cual permite resolver una amplia gama de circuitos combinatorios, donde la única restricción radica en el tamaño en memoria necesario para representar el circuito buscado, ya que en la programación genética, el tiempo de respuesta y el manejo de memoria se ven afectados por el tamaño de la población y el tamaño de cada individuo (representados internamente como arboles n-arios). Otro logro obtenido, radica en el tipo de dispositivo capaz de aceptar la configuración resultante dada por la aplicación. En primera instancia se planteó el uso exclusivo de circuitos FPGA, con la intención de poder modificar directamente la estructura que definía el circuito, el cual debe ser fiel a un File description (archivo de configuracion) propio de Xilinx, y cuya estructura no es del dominio público por obvias razones. Entonces, al investigar los diversos métodos existentes para la programación de un circuito FPGA y gracias a la información facilitada vía Internet y correo certificado por XILINX, se llegó a la conclusión que una forma eficiente y por demás interesante sería el uso de lenguajes de alto nivel para la descripción de hardware VHDL (VHSIC Hardware Description Lenguage), siguiendo los estándares básicos de la IEEE. SimEHDL trabaja conjuntamente con el software Foundation de Xilinx, el cual recibe el código VHDL sintácticamente correcto y es capaz de simular, implementar y configurar una gran cantidad de circuitos. Dicho software fue usado en la presente investigación para la realización de las diferentes pruebas realizadas. A continuación se detalla en forma porcentual, cada uno de los objetivos propuestos y su cumplimiento:

115

1. Diseñar e implementar un simulador para la construcción de circuitos combinacionales por medio de algoritmos genéticos con aplicación a un sumador de 3 bits, orientado a dispositivos reprogramables. Cumplimiento: 100%. Aclaración: El simulador no sólo encuentra el circuito sumador de 3 bits, también

encuentra cualquier circuito combinatorio con ciertas restricciones de tamaño, como son: número máximo de salidas, numero máximo de entrada y cantidad de funciones involucradas.

2. Diseñar el software necesario para simular los componentes esenciales del dispositivo lógico

programable (FPGA) para un circuito sumador de 3 bits. Cumplimiento: 100% Aclaración: Al realizar la respectiva investigación con respecto a los circuitos FPGA, se

encontró que por restricciones de derechos de autor, no era posible realizar el desarrollo del algoritmo genético directamente sobre la cadena de bits que configuran el FPGA, por ello se decidió atacar el problema, con la poderosa herramienta VHDL, lenguaje de programación 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 diseñar un algoritmo genético capaz de programar el dispositivo lógico

programable (FPGA) simulado para el sumador de 3 bits. Cumplimiento: 100%

4. Diseñar e implementar una Interface capaz de interactuar con el algoritmo genético y el

software simulador de FPGA para el sumador de 3 bits. Cumplimiento: 100%

116

CONCLUSIONES Y RECOMENDACIONES La investigación 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 Ingeniería y otras se interesen en todo el conjunto de aplicaciones que se pueden realizar. Como se plantea en la recopilación teórica, éste trabajo pertenece al nivel de Hardware Evolutivo Extrínseco (OFFLINE), donde la evolución de los individuos se lleva a cabo en una máquina (PC) diferente al dispositivo que se desea configurar. Así entonces el siguiente paso lógico para continuar con el proceso de esta investigación, es el cálculo de la aptitud dentro del dispositivo reprogramable, con pequeñas modificaciones a esta aplicación y con los implementos necesarios (Hardware y Software) se puede llevar a cabo una aproximación en paralelo calculando la aptitud de varios individuos a la vez en un mismo dispositivo reprogramable. El paso siguiente es la creación de una aplicación que permita la configuración a bajo de nivel de un dispositivo reprogramable. Para esto, se necesitarían, 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 usaría entonces para el cálculo de la aptitud, pero el algoritmo genético seguiría ejecutándose sobre un PC. Por último, la aplicación más interesante seria interdisciplinaria. El diseño del programa genético dentro del dispositivo programable (Hardware Evolutivo Intrínseco). Existe una gran cantidad de información en Internet acerca de circuitos que se configuran por sí solos con capacidad de autoreparación, usando un algoritmo genético.

117

BIBLIOGRAFIA [1] MARTINEZ, J.J., Notas de clase Programación 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., Ingeniería del Software: Un enfoque practico, McGrawHill Interamericana, España, 1993. [5] MAÑANA, GABRIEL, Memorias del Curso de Análisis y Diseño Orientados por Objetos (ADOO), Universidad Nacional de Colombia, 1994. [6]GALIB, MIT Dirección 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., Lógica Digital y Diseño 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 Dirección electrónica de la organización VHDL. [18] www.geneticprogramming.org

118

[19] www.geneticprogramming.com

119

MANUAL DEL USUARIO Sim-EHDL es una herramienta que permite el diseño de circuitos combinacionales, al generar el código del circuito buscado en lenguaje VHDL, esto se logra gracias a la programación genética, la aplicación comprende dos programas: Sim-EHDL (la simulación como tal) y Editor de Tablas, los cuales son explicados a continuación, con el seguimiento a un ejemplo práctico. 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 opción 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 Inicialización, 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 combinación de entradas en la misma fila, las cuales se modifican con un clic izquierdo del ratón sobre la casilla deseada. Una vez editada la tabla de verdad deseada, se procede a salvar su contenido en un archivo con extensión .tdv por cualquiera de las opciones Guardar o Guardar Como del menú Archivo.

Con el archivo .tdv creado el usuario puede programar con la aplicación SimEHDL Sim-EHDL Este programa, recibe la Tabla de Verdad del circuito buscado y por medio de la configuración de un algoritmo de programación genética, realiza la búsqueda del mejor programa VHDL que da solución al problema.

Para iniciar entonces en el menú Archivo seleccione la opción Nuevo Proyecto o Abrir (en caso de que ya existan proyectos creados de extensión .cfg, estos archivos, guardan todos los datos de configuración de un algoritmo genético), con lo cual se abren las siguientes ventanas: Funciones Lógicas y Parámetros, luego de modificadas estas, puede entonces definirse el problema a resolver, en la opción Definir Problema del menú Problema, que no es otra que la tabla de verdad del circuito buscado.

121

Ventana de Funciones Lógicas En ella se pueden observar las funciones básicas que utiliza el algoritmo, además de las funciones del usuario. El usuario puede definir una función de manera muy simple, consistente en la edición de una tabla de verdad para la función que desea implementar en el Editor de Tablas, con la única restricción de que esta solo puede tener una salida.

Para Insertar nuevas funciones, seleccione una de las dos opciones Básicas o Definidas y con el botón Insertar aparecerá según el caso o la lista de funciones básicas (AND, OR, XOR, NOT) o el directorio para seleccionar un archivo .tdv. Así, si desea desactivar una función ya sea básica o definida, lo que debe hacer es: 1. Ubicarse con el ratón sobre la función que desea desactivar y con un clic izquierdo

seleccionarla. 2. Luego con el botón Remover, se saca de la lista la función seleccionada. Ventana de Parámetros En ella se configura el algoritmo de programación genética, esta dividida en cuatro partes, descritas a continuación: 1. Creación de la población inicial:

♦ Número de Niveles: Corresponde al máximo número de niveles de profundidad que logrará la

población inicial, acepta un rango de valores de 1 a 10 (sin contar la raíz del árbol).

122

♦ Número de Individuos: Es el número de individuos (árboles) en la población inicial y subsiguientes, acepta un rango de valores entre 1 y 100.

♦ Porcentaje Función-Terminal: Corresponde a una probabilidad , que según su valor coloca o no funciones o terminales en algún nivel del árbol generado, por ejemplo si el valor es de 100% en Función, los árboles generados en la primera generación, tendrán todos sus niveles llenos hasta la profundidad máxima, este parámetro permite un mayor grado de aleatoriedad en la creación de la población 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 Básicas-Usuario: Ésta se refiere a la probabilidad con que serán elegidas las funciones básicas o de usuario para la generación de la población inicial de árboles.

2. Programa Genético: General:

♦ Número de Generaciones: Corresponde al número generaciones durante el cual se ejecutará el

algoritmo de programación genética. Su rango es de 1 a 3000. ♦ Terminación: Se refiere a la condición de terminación del algoritmo. Se tienen las opciones:

1.Perfección: detiene la ejecución tan pronto se encuentre un individuo con aptitud perfecta. 2. Número de Generaciones: el algoritmo se ejecuta hasta que se cumpla la cantidad de generaciones establecidas. 3. Convergencia: Según valores configurados, se detiene si no mejora la aptitud del mejor individuo tras un número dado de generaciones en un radio determinado.

♦ Tipo de Selección: Activa uno de tres tipos de selección definidos (MEJOR INDIVIDUO, RULETA y TORNEO).

♦ Circuitos Combinatorios: define la forma en que se calculara la aptitud de un individuo, bien sea por número de bits correctos o por número de palabras correctas, para el primero, es posible además incluir un castigo para los individuos que sobrepasen el tamaño en niveles definido (Número Máximo), el castigo no debe ser mayor o igual a 1.

123

3. Programa Genético: Probabilidades:

♦ Básicas: definen las probabilidades para el algoritmo de programación genética, como son

cruce, mutación y reemplazo de población. ♦ Convergencia: Define los valores para la terminación por convergencia. 4. Manejo de Archivos:

♦ Cada CheckBox activa la opción de generar el archivo con la extensión respectiva y con el

mismo nombre de la tabla de verdad del circuito buscado. Ejecución del Algoritmo Una vez definidos los parámetros de ejecución y la tabla de verdad del circuito a buscar se procederá a ejecutar el algoritmo con la opción Ejecutar del menú Ejecutar. Durante la ejecución é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 Gráfica de Aptitud (Con la gráfica de Aptitud del mejor individuo Vs. Generación).

124

Al terminar la ejecución del algoritmo, en el menú resultados se pueden activar las siguientes ventanas: código LISP, Código VHDL, Gráfica de Estadísticas y Archivo de Estadísticas.

125

126

La Opción Encadenar del Menú A pesar de que el código VHDL final es sintácticamente correcto, es necesario probarlo, para ello la opción Encadenar facilita la interacción con el Xilinx Foundation Software de la siguiente manera: Inicialmente Xilinx Foundation supone la existencia de varias entidades en el proceso de síntesis, 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 diseñar. Además se almacena el código VHDL generado dentro del proyecto Foundation. Con este procedimiento, el usuario puede usar el programa como una macro o un componente dentro de su diseño. INSTALACION Para instalar el software necesario para la ejecución de SimEHDL y del Editor de Tablas, Inserte el CD-ROM con el software de instalación, lea el archivo LEAME.TXT, el cual contiene la descripción 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 DISEÑO

La metodología que se aplico para las fases de análisis y diseño del problema, combina la ingeniería de software tradicional con el ciclo de vida propuesto en el documento de G. Mañana[5], el cual abarca las siguientes actividades: Ingeniería y análisis del sistema: Fase en la cual se establecen los requisitos iniciales del

sistema, es decir lo que se espera que éste haga, en relación con le hardware en el que operará y las personas que lo usarán. Diseño: Según Pressman[4], el diseño del software se centra en “...cuatro atributos distintos

del programa: la estructura de los datos, la arquitectura del software, el detalle procedimental y la caracterización de la interfaz...”, así, el diseño consiste en presentar en forma más detallada los requerimientos definidos en el paso anterior, organizándolos con respecto a los cuatro tópicos enunciados anteriormente. Implementación: Es la traducción del diseño a un lenguaje de programación (codificación). Prueba: Pressman[4] enuncia en este sentido: “...Una vez que se ha generado el código,

comienza la prueba del programa. La prueba se centra en la lógica 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 módulos, 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 límites definidos entre los diferentes pasos, y se supone que puede ser necesario en algunos casos regresar al paso anterior para afinar el diseño o el análisis de requerimientos o el código mismo del programa según sea necesario. La metodología empleada es la orientada por objetos, se hará una breve presentación de ella principalmente fundamentada en la metodología expuesta por Mañana[5]. Clases del Sistema La primera tarea en el diseño de un sistema es encontrar las clases que lo componen. Para ello se realiza la especificación de requerimientos del sistema, la cual debe incluir los objetivos de la aplicación, las entradas esperadas y las respuestas deseadas. Se debe leer cuidadosamente señalando las frases nominales, con ello obtenemos una lista preliminar. En ésta lista aparecerán frases que incluyen clases obvias, frases que no tiene ningún sentido y frases sobre las cuales no se puede estar seguro. No todas las clases candidatas estarán en el diseño final y algunas posiblemente serán 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 genéricos y aquellas que representan conjuntos de uno o más 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 aplicación, la mayoría de estas clases serán descendientes de las abstractas (por esto son llamadas superclases). Exploración Inicial El proceso de diseño 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 descripción del conocimiento, las responsabilidades de cada clase y las colaboraciones entre ellas. Análisis Detallado Con los datos encontrados en la exploración, se inicia la etapa de proceso del diseño, 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 serán re-ubicadas en las superclases. Se analiza también el esquema de colaboración 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 demás?, ¿hay clases que no colaboran con ninguna otra?, de ser así, ¿deben ser descartadas?. En las tarjetas donde se lleva la información de cada clase se agregan las clases y subclases correspondientes. Los pasos anteriores están encaminados a producir un diseño inicial. Se identifican las clases del sistema, sus responsabilidades y las colaboraciones que garantizan los servicios requeridos. Se analizan después las relaciones de herencia entre las clases y se identifican los contratos soportados, y se refina al diseño simplificando los patrones de comunicación 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 propósito de la clase dentro de la aplicación. Estas tarjetas también servirán para registrar las responsabilidades de cada clase.

131

Responsabilidades Es en éste momento del diseño en donde se define el propósito de la clase asignándole conocimiento y comportamiento, es decir, se determinan las responsabilidades de cada clase. Dichas responsabilidades incluyen los siguientes tópicos: 1. El conocimiento que la clase debe mantener. 2. Las acciones que la clase debe realizar. Las responsabilidades pueden ser identificadas, señalando en la especificación de requerimientos los verbos que representen acciones que algún objeto del sistema deba realizar; es importante tener en cuenta la información manipulada por el sistema, ya que ésta también representa responsabilidades de algún objeto. El propósito descrito en cada tarjeta de clase también nos indica responsabilidades, se debe saber que conocimiento y acciones están implicadas en dicho propósito 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 información 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 están 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 Transición de Estados Una de las maneras más útiles para obtener la información del sistema consiste en recorrer la aplicación por diferentes caminos (walk-through), imaginando como es invocado cada servicio, viendo que otras responsabilidades están implicadas en él y utilizando todos los servicios que pueda prestare el sistema. Para realizar esto se cuenta con una herramienta llamada diagrama de transición de estados (DTE) de la aplicación.

132

ANEXO B. GALIB

Visión General GALib es una librería desarrollada en el MIT (Massachusetts Institute of Technology), que provee un conjunto de objetos para algoritmos genéticos en C++. Aunque esta librería es bastante compleja, puede entenderse con el estudio de dos clases principales: Genoma y una Algoritmo Genético. Cada instancia del Genoma representa una solución sencilla al problema. El objeto Algoritmo genético define como tendrá lugar la evolución. En el algoritmo genético se usa una función objetivo (definida por el usuario) para determinar la supervivencia de los genomas. Esto usa los operadores (construidos dentro del genoma) y las estrategias de selección y reemplazamiento para generar nuevos individuos. Para resolver un problema usando algoritmos genéticos se definen tres pasos: 1. Definir una representación 2. Definir los operadores genéticos 3. Definir la función objetivo

GALib ayuda con los dos primeros ítems al proveer varios ejemplos y piezas de los cuales se puede construir la representación y operadores. En GALib, el genoma se trabaja a través 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 básicos de algoritmos genéticos: - Simple: (Descrito por Goldberg en su libro Genetic Algorithms in Search and Optimizations)

Este algoritmo no usa superposición de la población (supervivencia de un individuo varias generaciones) y es opcionalmente elitista.

- Steady-State: Usa superposición de la población, en esta variación se puede especificar cuanta población debe ser reemplazada en cada generación.

- Incremental: En este caso la población consta de sólo uno o dos hijos, este tipo permite la personalización del método de reemplazamiento para definir como debe ser creada la nueva población.

133

- 'deme': Este tipo involucra múltiples poblaciones en paralelo usando un algoritmo steady-state, cada generación el algoritmo migra algunos individuos de cada población a otras poblaciones.

Estos algoritmos difieren en la forma en que crean nuevos individuos y reemplazan los antiguos durante el curso de la evolución. GALib trae ejemplos de derivación de nuevas clases, además tiene predefinidos tres operadores sobre los diferentes tipos de genomas: inicialización, cruce y mutación que se pueden personalizar para nuevos tipos de genomas obtenidos derivando la clase GAGenome. Además cada genoma contiene una función objetivo (determinada por el usuario) y alguna forma de comparación (llamada por algunos función de distancia). En general el desarrollo del algoritmo genético es independiente del tipo de dato con que se trabaje el genoma. La librería refleja esta generalidad. Objeto Población GALib maneja el objeto población el cual es un contenedor de genomas. Cada objeto población tiene su propio inicializador (por defecto es llamar al inicializador de cada sujeto de la población) y evaluador (por defecto llama al evaluador de cada sujeto). Esto permite llevar una serie de estadísticas tales como: el mejor individuo, el promedio, y la desviación estándar de cada población, pero estos cálculos no se llevan por defecto ya que pueden llegar a consumir bastantes recursos del sistema. El método de selección (en el cual se escogen cuales individuos se reproducen con cuales) es también definido en el objeto población. Cada objeto población 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 genético usa para la selección. Esto también oculta la información de aptitud para usarla posteriormente por el esquema de selección Función Objetivo Una de las grandes ventajas de los algoritmos genéticos frente a otros métodos es que sólo necesitan una medida de qué tan bueno es un individuo comparado con otros. La función objetivo es esta medida, mientras el puntaje de aptitud determina la capacidad de un individuo para reproducirse (muchas veces no se usa función objetivo). Operadores Aquí se observan algunos ejemplos de los tipos de cruces y mutaciones que pueden ser efectuados usando GALib

134

Los operadores (que también 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 además el uso de funciones puntero en vez de funciones miembro permite cambiar los operadores en tiempo de ejecución. Y ellos son más rápidos 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 números 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 genético tiene por defecto los operadores definidos en esta clase. Guarda estadísticas de la evolución tales como el número de mutaciones, el número de cruces, el número de evaluaciones, el mejor, la media, el peor de cada generación, y estadísticas de la población inicial y de la actual. Aquí también se define la terminación, una función miembro que especifica el criterio de parada del algoritmo. Se puede maximizar o minimizar por llamadas a las funciones apropiadas. Los parámetros tales como generaciones a completar, probabilidad de cruce o de mutación pueden ser dados por un archivo, por la línea de comandos o por medio de funciones miembro. Descripción de Funciones Miembro convergence: Retorna la actual convergencia. La convergencia está definida como la razón entre el N-esimo mejor puntaje y el mejor puntaje actual. Crossover: Especifica el método de cruce durante la evolución, este puede cambiar durante el curso de una evolución. Done: Retorna gaTrue si el criterio de terminación ha sido alcanzado, retorna gaFalse en otro caso. Evolve: lnicializa el algoritmo genético y evoluciona mientras el criterio de terminación 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 generación. Initialize: lnicializa el algoritmo genético, si se le introduce un valor de semilla llama a GARandomSeed con este valor. NBestGenomes: Especifica cuantos mejores puntajes guardar. Nconvergence: Especifica el número de generaciones usadas para la prueba de convergencia. Ngenerations: Da el número de generaciones. Objectivedata: Pone los datos miembro objetivo en todos los individuos usados por el algoritmo genético. Estos pueden cambiar durante la ejecución. Objectivefunction: Coloca la función objetivo en todos los individuos. Parameters: Retorna una referencia a la lista de parámetros con sus valores actuales. parameters(GAParameterList&): Fija los parámetros para el algoritmo genético. pconvergence: Da el porcentaje de convergencia. pcrossove: Pone la probabilidad de cruce. Pmutation: Coloca la probabilidad de mutación. Population: Da la población. Retorna una referencia a la actual población. Populationsize: Fija el tamaño de la población. Este puede ser cambiado durante el curso de una evolución. RecordDiversity: Especifica si es necesario calcular o no la diversidad. La diversidad requiere la comparación de cada individuo con cada uno de los otros. Por defecto es gaFalse. RegisterDefauItParameters: Registra los parámetros por defecto, los parámetros 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 selección para el algoritmo genético. SelectScores: Determina cuales valores (estadísticos) se salvan en disco. Set: Fija un parámetro individual para el algoritmo genético. Statistics: Retorna una referencia al objeto estadística (mejor, peor, medio, desviación estándar y diversidad de cada generación). Step: Evoluciona el algoritmo genético una generación. Terminator: Da la función de terminación. Userdata: Pone los datos para usar en el algoritmo genético. GAGenome Esta es una clase virtual y no puede ser instanciada. Esta define un número de constantes y funciones prototipo especificas al genoma y sus clases derivadas. La dimensión es usada para especificar cual dimensión es referenciada en un genoma multi-dimensional. El método clone especifica si clonar el genoma entero (un nuevo genoma con contenido igual al original debe ser creado) o sólo los atributos del genoma (un nuevo genoma con características idénticas al original se crear) en ambos casos la llamada es responsable por borrar la cantidad de memoria por la función miembro clone.

137

Los operadores genéticos para genomas son funciones que toman genomas genéricos como sus argumentos. Esto hace posible definir nuevos comportamientos para clases de genomas existentes sin derivar una nueva clase.

Descripción de Funciones Miembro clone: Este método localiza espacio para un nuevo genoma mientras el método copia usa el espacio para el genoma al cual pertenece. compare: Compara dos genomas. La comparación puede ser basada en el genotipo (o fenotipo), si los genomas son idénticos retorna cero. comparator: Fija el método de comparación. copy: Se usa para copiar los contenidos de un genoma en otro existente, esta función es llamada por el operador de clase = y por el miembro clone. crossover: Cada clase genoma puede definir el método de cruce preferido. Este método asigna el método de cruce preferido para una instancia del genoma. equal, notequal: Son específicos del genoma. evaldata: Pone el objeto usado para almacenar los datos de evaluación del genoma especifico. evaluate: Invoca la función de evaluación del genoma. evaluator: Especifica la función de evaluación del genoma. geneticalgorithm: Esta función miembro retorna un puntero al algoritmo genético "propietario" del genoma. initialize: Llama la función de iniciación para el genoma. initializer: Carga el método de iniciación. mutate: Llama el método de mutación para el genoma. mutator: Fija el método de mutación. nevals: Retorna el número de evaluaciones de la función objetivo desde que el genoma fue inicializado. operator == , operator != , operator <<, operator >>: Estos métodos llaman la función miembro virtual asociada. Ellos pueden ser usados por algún genoma genérico. read: Llena el genoma con los datos leídos desde el flujo especificado. sexual, asexual: Retorna un puntero al método de cruce preferido por este genoma. score: Retorna el puntaje objetivo del genoma usando la función objetivo asignada al genoma. userdata: Cada genoma contiene un puntero genérico a datos específicos del usuario, esta función miembro retorna este puntero. write: Envía los contenidos del genoma al flujo especificado. GAStatics El objeto estadísticas contiene información sobre el actual estado del objeto algoritmo genético. Cada algoritmo genético contiene un objeto estadísticas. Descripción de Funciones Miembro bestever: Retorna el puntaje del mejor individuo encontrado. bestindividual: Esta función retorna la referencia del mejor individuo encontrado por el algoritmo genético. bestpopulation: Devuelve la referencia a la población que contiene el mejor individuo encontrado por el algoritmo genético. convergence: Retorna la actual convergencia. La convergencia está definida como la razón entre el N-esimo mejor puntaje y el mejor puntaje actual. crossovers: Retorna el número de cruces que han ocurrido desde la iniciación.

138

current: Devuelve el puntaje especifico de la población actual. flushfrecuency. Especifica que tan a menudo (número 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 número de la generación actual. inicial: Indica el puntaje de la población inicial. mutations : Muestra el número de mutaciones que han ocurrido desde la iniciación nBestGenomes: Especifica cuantos mejores puntajes guardar nconvergence: Especifica el número de generaciones usadas para la prueba de convergencia. offline: Devuelve el promedio de los mejores puntajes de la generación. online: Otorga el promedio de todos los puntajes. recordDiversity: Esta opción booleana determina si la diversidad de una población debe ser calculada para cada generación. Por defecto esta opción es falsa. replacements : Indica el número de sustituciones que han ocurrido desde el inicio. reset: Elimina el contenido del objeto estadísticas usando el contenido de la población especifica. scorefilename: Fija el nombre del archivo en el cual se guardarán los puntajes de salida, por defecto este nombre es "generations.dat' scorefrequency: Determina la frecuencia con la cual el puntaje de la generación debe ser registrado, la opción por defecto depende del tipo de algoritmo que se este usando. scores: Imprime los puntajes de la generación en el flujo especificado selectscores : Esta función se usa para especificar cuales puntajes deben ser salvados en disco (media, máximo, mínimo, desviación estándar, diversidad). update: Actualiza los contenidos del objeto estadísticas reflejando el estado de la población especificada. worstEver: Retorna el puntaje del peor individuo encontrado. bestever: Devuelve el puntaje del mejor individuo encontrado. Funciones para el Manejo de Números Aleatorios GAlib incluye las siguientes funciones para la generación de números 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 función GARandomSeed usa la hora actual multiplicado por el identificador del proceso como semilla para un generador de números pseudo - aleatorios si se llama con algún 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 números aleatorios usando el nuevo valor. 139

GAFlipCoin retorna un valor booleano basado en un sesgo dado. La función GARandomBit es la más eficiente forma de nos sesgar los resultados. La función Gaussiana retorna a un número que sigue la distribución Gaussiana con una desviación especificada. La función GAUnitGaussian retorna a número que sigue una distribución Gauss normalizada (media 0 y varianza 1). GAlib usa un solo generador de números aleatorios para toda la librería que puede ser cambiado cuando se compila la librería Manejo de Errores Si una función 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 impresión de errores pasando gaFalse a la función GAReportErrors. Si se quiere redireccionar el mensaje de error a un flujo diferente se asigna el nuevo flujo usando la función 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 diseño de circuitos programables Realizar simulación funcional y cronométrica del diseño Implementar el diseño Programar un dispositivo

En este capítulo se reseñan las características básicas de XILINX FOUNDATION que fueron útiles para la prueba de los circuitos encontrados por medio del programa SimEHDL presentado en esta investigación. 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 lógicos programables. XILINX FOUNDATION está compuesto por diversos módulos, que no serán detallados en este informe. Simplemente se listan a continuación los pasos básicos para la programación de un dispositivo lógico desde la etapa de diseño hasta la carga física de la configuración en le circuito lógico programable. DISEÑO DEL CIRCUITO El diseño del circuito puede hacerse por medio de diagramas, máquinas de estado finito, o lenguajes de descripción de hardware tales como VHDL o VERILOG. En el proyecto que se realiza, el enfoque utilizado es el esquemático (diseño gráfico de la red del circuito), donde se puede insertar un bloque lógico (caja negra) que corresponde a una macro creada en lenguaje VHDL. XILIX Foundation cuenta con un editor de código VHDL que permite además del ingreso del diseño por medio de este lenguaje, la compilación de sintaxis, la síntesis del circuito y la creación de una macro para ser utilizada dentro de un proyecto esquemático.

141

Una vez se ha creado una macro puede insertarse dentro del diseño normal de un circuito. Así,. Un bloque lógico creado en VHDL que funciona como un sumador de 3 bits puede hacer parte de un sistema más complejo creado por medio del enfoque esquemático.

142

SIMULACION Cuando se tiene el diseño del circuito, se procede a la fase de simulación. Se usa la simulación funcional, para estudiar el comportamiento de las señales de salida de acuerdo únicamente a las combinaciones de las señales de entrada (para circuitos combinatorios). Una forma de realizar simulación dentro del entorno XILINX FOUNDATION, consiste en seleccionar todas las señales que desean estudiarse (bien sean de entrada, salida o entrada/salida). Entonces, el paquete permite asociar diversos tipos de estímulos a las señales de entradas, tales como: ♦ Entradas de Usuario ♦ Pulsos de Reloj ♦ Secuencias La siguiente gráfica refleja un instante en la simulación de un circuito sumador de 3 bits:

IMPLEMENTACION Después de haber comprobado el funcionamiento del circuito en el ambiente simulador, el usuario puede pasar a una fase de implementación. 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 verificación específica 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 diseño en un archivo bitstream capaz de programar el circuito lógico.

PROGRAMACION Por último, el usuario puede cargar la configuración recién creada en el dispositivo físico utilizando un puerto de intercambio de datos, y una tarjeta compatible.

144