desarrollo de un sistema de selección de componentes de

UNIVERSIDAD DE LOS ANDES
FACULTAD DE INGENIERÍA
ESCUELA DE SISTEMAS
DEPARTAMENTO DE COMPUTACIÓN
MÉRIDA ESTADO MÉRIDA
DESARROLLO DE UN SISTEMA DE SELECCIÓN DE COMPONENTES DE
SOFTWARE UTILIZANDO INTELIGENCIA ARTIFICIAL COLECTIVA
Proyecto de grado presentado ante la Ilustre Universidad de Los Andes como requisito final
para optar al título de Ingeniero de Sistemas
Autor: Juan J. Bastidas B.
Tutor: Prof. Jose Aguilar
Julio, 2006
i
Dedicado a Dios omnipresente,
a la memoria de mi papá, y a
toda mi familia.............
ii
AGRADECIMIENTOS
Mis mas sinceros agradecimientos, tanto al profesor Jose Aguilar como a la
Ingeniero Blanca por toda la colaboración prestada, y por haber sido mis guías en el
desarrollo de este trabajo. Igualmente a todo mi grupo de amigos, compañeros que de una u
otra manera contribuyeron en la consecución de este objetivo.
iii
DESARROLLO DE UN SISTEMA DE SELECCIÓN DE COMPONENTES DE
SOFTWARE UTILIZANDO INTELIGENCIA ARTIFICIAL COLECTIVA
RESUMEN
En este trabajo se propone un sistema de selección de componentes de software
basado en conceptos de Inteligencia Artificial Colectiva (IAC). La dinámica dependerá del
numero de agentes inteligentes en el sistema, encargados de realizar la búsqueda, en
diferentes repositorios de componentes en la Internet, y selección de los componentes
requeridos. Los componentes tienen asociado un archivo XML, el cual contiene las
características más relevantes del mismo y a su vez almacena la marca relacionada con su
rendimiento (traza de feromona). La traza de feromona es un concepto asociado a la teoría
de IAC, que ha sido la principal inspiración de este trabajo. La IAC se basa en la capacidad
que tienen algunos insectos para trabajar individualmente con el fin de alcanzar metas
colectivas, cada insecto es visto como un agente. Este modelo propuesto puede ser utilizado
no solo para la selección de componentes de software, sino también para la selección de
servicios, recursos etc., pues es lo suficientemente general para ser replicado según
requerimientos particulares.
Palabras claves:
Inteligencia Artificial Colectiva, repositorio de componentes, componentes de software,
agentes inteligentes, Ingeniería de Componentes.
iv
INDICE GENERAL
Pág.
CAPITULO I: DEFINICIÓN DEL PROBLEMA......................................................
1
1.1. Introducción.........................................................................................................
1.2. Planteamiento del problema.................................................................................
1.3. Justificación de la investigación...........................................................................
1.4. Antecedentes de la investigación.........................................................................
1.5. Objetivos de la investigación...............................................................................
1.5.1. Objetivo General........................................................................................
1.5.2. Objetivos específicos.................................................................................
1
2
3
4
9
9
9
CAPITULO II: MARCO TEORICO..........................................................................
11
2.1. Inteligencia Artificial Colectiva...........................................................................
2.1.1. Formulas básicas del modelo.....................................................................
2.2. Ingeniería de Software Basada en Componentes.................................................
2.2.1. Componente de software...........................................................................
2.2.2. Arquitectura basada en componente..........................................................
2.2.3. Características mas relevantes de los componentes de software...............
2.2.4. Modelos de componentes..........................................................................
11
13
14
14
15
16
17
CAPITULO III: DISEÑO DEL ALGORITMO.........................................................
20
3.1. Generalidades.......................................................................................................
3.2. Atributos a considerar en la caracterización de los componentes de software....
3.3. Modelo de selección.............................................................................................
3.4. Macro Algoritmo..................................................................................................
20
21
22
26
CAPITULO IV: CONSTRUCCIÓN DEL SISTEMA...............................................
27
4.1. Modelado Funcional del Sistema.........................................................................
4.1.1. Diagramas de casos de uso........................................................................
4.1.2. Diagramas de actividades..........................................................................
4.2. El sistema programado.........................................................................................
4.3. Descripción de la interfaz gráfica........................................................................
27
27
32
36
39
CAPITULO V: PRUEBAS DEL SISTEMA...............................................................
43
5.1. Criterios de selección de componentes más usados.............................................
5.2. Descripción de los experimentos.........................................................................
5.2.1. Experimento 1............................................................................................
5.2.2. Experimento 2............................................................................................
5.3. Análisis de los resultados.....................................................................................
5.3.1. Experimento 1............................................................................................
43
44
45
46
47
48
v
5.3.2. Experimento 2............................................................................................ 49
CAPITULO VI: CONCLUSIONES Y RECOMENDACIONES.............................. 51
BIBLIOGRAFÍA............................................................................................................ 53
APÉNDICE. TABLAS DE RESULTADOS................................................................
57
vi
INDICE DE TABLAS
Pág.
Tabla 1. Descripción del caso de uso Solicitar Componentes.........................................
28
Tabla 2. Descripción de la extensión Descripción..........................................................
28
Tabla 3. Descripción del caso de uso Seleccionar Componentes....................................
29
Tabla 4. Descripción de la extensión Visitar Repositorios..............................................
30
Tabla 5. Descripción de la extensión Calcular Correspondencia...................................
30
Tabla 6. Descripción de la extensión Calcular Probabilidad de Selección....................
30
Tabla 7. Descripción del caso de uso Actualizar Feromona...........................................
31
Tabla 8. Descripción de la extensión Calcular Tasa de Evaporación de la Traza.........
32
Tabla 9. Descripción de la extensión Depositar Feromona............................................
32
Tabla 10. Descripción de los componentes requeridos.................................................... 45
Tabla 11. Orden de ejecución del sistema.......................................................................
45
Tabla 12. Descripción de los componentes requeridos.................................................... 46
Tabla 13. Orden de ejecución del sistema.......................................................................
47
Tabla 14. Primera corrida................................................................................................
58
Tabla 15. Segunda corrida...............................................................................................
58
Tabla 16. Tercera corrida................................................................................................. 58
Tabla 17. Cuarta corrida..................................................................................................
59
Tabla 18. Primera corrida................................................................................................
62
Tabla 19. Segunda corrida...............................................................................................
63
Tabla 20. Tercera corrida................................................................................................. 64
Tabla 21. Continuación tercera corrida............................................................................ 66
vii
INDICE DE FIGURAS
Pág.
Figura 2.1. Esquema de un Componente y su contenedor...............................................
15
Figura 2.2. Arquitectura del software de una aplicación basada en componentes..........
15
Figura 3.1. Archivo de Perfil del Componente................................................................
21
Figura 3.2. Modelo de componente.................................................................................
22
Figura 3.3. Modelo de Selección. Cada agente busca el grupo de componentes a
utilizar..............................................................................................................................
23
Figura 4.1. Diagrama que muestra el caso de uso solicitar componentes.......................
28
Figura 4.2. Diagrama que muestra el caso de uso Seleccionar Componentes.................
29
Figura 4.3. Diagrama que muestra el caso de uso Actualizar Feromona......................... 31
Figura 4.4. Actividades generadas por caso de uso: Solicitar Componentes..................
33
Figura 4.5. Actividades generadas por caso de uso: Seleccionar Componentes..........
34
Figura 4.6. Actividades generadas por caso de uso: Actualizar Feromona..................
35
Figura 4.7. Diagrama de Componentes...........................................................................
36
Figura 4.8. Diagrama de clases del diseño....................................................................... 38
Figura 4.9. Interfaz con el Usuario..................................................................................
40
Figura 4.10. Interfaz con el Usuario. Descripción de los Componentes.........................
40
Figura 4.11. Agregar Perfil Deseado...............................................................................
41
Figura 4.12. Dialogo informativo. El perfil deseado del componente 2 solicitado, no
ha sido especificado.........................................................................................................
41
Figura 4.13. Ventana que muestra el resultado de la búsqueda y selección del grupo
de componentes de software hecha por cada agente........................................................ 42
viii
CAPITULO Ι
DEFINICIÓN DEL PROBLEMA
1.1.
Introducción
La creciente necesidad de realizar sistemas de software complejos en cortos
periodos de tiempo, a la vez que con menores esfuerzos tanto humanos como económicos,
está favoreciendo el avance de lo que se conoce como Desarrollo de Software Basado en
Componentes (DSBC). Esta disciplina se apoya en componentes de software ya
desarrollados, que son combinados adecuadamente para satisfacer los requisitos del
sistema. Dicha disciplina cuenta actualmente con un creciente interés, tanto desde el punto
de vista académico como desde la industria, en donde la existencia de mecanismos y
herramientas de desarrollo basadas en componentes es cada día mayor [3].
Construir una aplicación se convierte en la búsqueda y ensamblaje de piezas
prefabricadas [3]. Bajo este planteamiento, cobran especial interés “los procesos de
búsqueda y selección de los componentes” siendo dichos procesos el objeto central de
nuestra tesis, en la cual se propone un algoritmo de selección de componentes inspirado en
conceptos de Inteligencia Artificial Colectiva (IAC).
El trabajo esta estructurado en 5 capítulos:
En este capitulo se hace el planteamiento formal del problema y se presenta los
antecedentes de la investigación.
El Capitulo ΙΙ contiene el marco teórico de la investigación donde se detallan
los fundamentos de las técnicas usadas para el desarrollo del Sistema de
Selección de Componentes de Software.
1
En el capitulo ΙΙΙ se hace una descripción precisa de las etapas del proceso de
Selección de Componentes de Software.
El capitulo IV esta enfocado a explicar la funcionalidad y el modo de operación
del sistema.
El capitulo V esta dedicado a la realización de experimentos para comprobar la
funcionalidad y efectividad, en cuanto a la selección de componentes por medio
del sistema desarrollado.
El capitulo VI, en función de los resultados y el conocimiento adquirido en la
realización del trabajo, se presenta las conclusiones y se dan algunas
recomendaciones.
1.2.
Planteamiento del problema
Hoy en día podemos decir que existe un consenso al considerar el “desarrollo
basado en componentes” como un avance significativo hacia la construcción de sistemas
mediante el ensamblado de componentes prefabricados. El DSBC trata de sentar las bases
para el diseño y desarrollo de aplicaciones distribuidas basadas en componentes software
reutilizables.
En ese paradigma pueden identificarse varios problemas para la construcción de
aplicaciones utilizando componentes [3]:
El problema de búsqueda de componentes que satisfagan los requisitos
impuestos, tanto por el cliente como por la arquitectura de la aplicación.
La evaluación de los componentes candidatos aborda el problema de
seleccionar los más idóneos.
El problema de la adaptación y/o extensión de los componentes seleccionados
para que se ajusten a los requisitos anteriores.
Y por último, el problema de la integración, configuración e interconexión de
dichos componentes para construir la aplicación final.
2
Es importante señalar que un factor imprescindible en todas esas tareas es la
documentación de los componentes, pues es preciso contar con especificaciones completas,
concisas y precisas de los componentes para poder llevar a cabo dichas tareas [3]. La
mayoría de las propuestas existentes para documentar componentes se basan en el uso de
interfaces, las cuales proporcionan un mecanismo para describir la funcionalidad de los
componentes. Sin embargo, los lenguajes de descripción de interfaces (IDLs) existentes
permiten documentar sólo los aspectos “sintácticos” (o “estáticos”) de dicha funcionalidad,
sin tratar otros aspectos de vital importancia como son los protocolos de acceso a los
servicios, el comportamiento de los métodos, o la semántica de las operaciones de los
componentes [4]. Por supuesto, dichos IDLs tampoco permiten tratar los aspectos “extrafuncionales” de los componentes, como la fiabilidad, la seguridad, o las prestaciones [5,6].
Respecto al problema de búsqueda, existen propuestas para la búsqueda de objetos
dentro de ciertos modelos (como RM-ODP) o plataformas (CORBA) [3]. También
comienzan a aparecer herramientas específicas para componentes, como por ejemplo el
denominado “COTStrader" (www.cotstrader.com). Dicha herramienta permite buscar y
seleccionar componentes a partir de la definición en plantillas XML de su funcionalidad y
otras propiedades de calidad.
El segundo problema se centra en los procesos y herramientas para la evaluación y
selección de componentes. Como se dijo antes, además de tener en cuenta los requisitos
funcionales de la aplicación, es necesario considerar otros factores que también intervienen
a la hora de seleccionar componentes. El problema es que este tipo de requisitos,
denominados “extra-funcionales”, son difíciles de evaluar, aunque seamos conscientes de la
importancia que representan. Este tipo de factores priman muchas veces, incluso más que
los funcionales, pues un diseñador es capaz de adaptar la arquitectura de un sistema para
incluir en ella un componente deseado, o bien para evitar la presencia de un componente de
un fabricante en el cual no se confía.
Como se dijo anteriormente, estos son los dos factores a estudiar en esta
investigación.
1.3.
Justificación de la investigación
Los desarrollos tradicionales de aplicaciones incurren en altos costos y en una
inversión de tiempo extensa. El iniciar un desarrollo de software desde cero es un reto muy
3
grande, incluso para una empresa que pueda soportar este proceso. Esto sesgaría el
desarrollo de software a las grandes empresas, y no le daría cabida a las pequeñas y
medianas empresas que desean adquirir tecnologías o construir sus propias soluciones. El
DSBC busca, dentro de otros objetivos, reducir el tiempo de trabajo, el esfuerzo que
requiere implementar una aplicación, y los costos del proyecto, y, de esta forma,
incrementar el nivel de productividad de los grupos desarrolladores y minimizar los riesgos
globales sin incurrir en gastos exorbitantes. Otra ventaja del DSBC es poder integrar lo
mejor de distintas tecnologías para desarrollar una aplicación de manera personalizada, a la
medida de las necesidades de los clientes. Otra gran ventaja es que permite a los
desarrolladores y a las empresas adquirir las tecnologías que más se adapten a sus
necesidades, muchas de las cuales son gratis y existen bajo la premisa de Freeware y GNU
(General Public License). Esto da como resultado la coexistencia, en una misma aplicación,
de componentes heterogéneos que ingresan o abandonan el sistema de forma dinámica, es
decir que los componentes pueden ser remplazados, por otros independientemente de su
arquitectura y desarrollo [7]. Por lo expuesto anteriormente, se deduce que el campo de
aplicación del DSBC es amplio.
1.4.
Antecedentes de la investigación
La primera vez que se habló formalmente de reutilización en el ámbito de la
ingeniería del software fue en el año 1968, cuando McIlroy propuso la creación de fábricas
de elementos de software análogas a las ya existentes de componentes hardware [19]. Los
foros de discusión de aquella época se centraban en localizar alguna solución viable a la
llamada crisis del software [19]: la demanda de creación y mantenimiento de sistemas de
software crecía vertiginosamente sin que las empresas del sector fueran capaces de hacerle
frente. En este contexto fue donde surgió la propuesta de McIlroy como factor a tener en
cuenta para la resolución de dicha crisis [8].
Desde entonces, y aunque los procesos de obtención de sistemas software han
evolucionado notablemente, mejorando e incrementando la producción de aplicaciones
software, todavía queda mucho por hacer frente a las necesidades de una sociedad cada vez
más consumidora y más dependiente del software y, consiguientemente, menos tolerante a
4
sus fallos. Ante esta situación, la reutilización de procesos y productos de software se divisa
como una alternativa realista y técnicamente factible [8].
Con respecto a la evolución de la “Ingeniería de componentes” se encuentra que esta
contenida en un área mayor, denominada “Ingeniería del Software”, cuyo crecimiento y
evolución se centra no solo en la necesidad de estandarizar los procesos y metodologías de
desarrollo, sino también en la posibilidad de reutilizar los objetos, funciones y códigos
desarrollados [20]. A mediados de los años 60 la creación de software era una tarea
sumamente difícil, lo cual hizo necesario la incorporación de herramientas que facilitaran la
creación de nuevo software y manejo del mismo, esto fue el inicio de lo que actualmente
conocemos como “Ingeniería del Software”. La aparición de componentes estándares y
reutilizables de software permite al ingeniero concentrarse en elementos verdaderamente
innovadores de un diseño, como por ejemplo las partes nuevas a crear; de allí surge la
“arquitectura de desarrollo del software” como una sub-área de la ingeniería del software,
la cual alude a la estructura global del software y las maneras en que esa estructura permite
la integración conceptual de los componentes que van a representar los elementos
principales del sistema [9]. Los componentes ingresan al mundo de la computación con el
fin de brindar una forma de crear activos reutilizables de una granularidad mayor a las
clases. Están ligados a otros conceptos de la ingeniería del software, tales como: Ingeniería
de Dominio, Líneas de Productos, Patrones de Diseño, entre otros [43]. Para un proceso de
desarrollo centrado en el reuso de componentes se debe realizar un trabajo de ingeniería de
dominio, la cual permite obtener para una línea de productos una arquitectura de referencia
y un conjunto de activos reutilizables: componentes, patrones, o combinaciones
organizadas entre estos [43].
La década de los 90 fue sin duda de consolidación y diseminación de la Arquitectura de
Software(AS) en una escala sin precedentes [10]. En esta misma época surge la
programación basada en componentes, lo cual impulsó a algunos arquitectos de software
como Paul Clements a afirmar que la AS promovía un modelo que debía estar enfocado
más a la integración de componentes pre-programados que a la programación como tal
[10].
El avance tecnológico de las telecomunicaciones y el incremento del uso de la
Internet, ha llevado al planteamiento del desarrollo de nuevas soluciones informáticas para
5
dar respuesta a problemas emergentes del área, y por consiguiente, a la aparición de nuevas
metodologías y entornos de desarrollo, los cuales hoy en día pueden ser distribuidos,
heterogéneos en cuanto al lenguaje utilizado, e incluso inteligentes [11]. Entre los esfuerzos
más recientes en esta área se encuentra el .net de Microsoft, el cual permite integrar fuentes
(generalmente componentes de software) desarrolladas en distintos lenguajes de
programación en un solo software que hace la interpretación y gestiona su integración;
también existen herramientas y lenguajes de programación como JADA, Smalltalk, Java,
entre otros, que permiten la incorporación de técnicas sofisticadas de programación como
reflexión, inteligencia artificial, distribución, etc. [20]. Igualmente, dentro del software libre
existen varios sistemas de componentes libres, a continuación se comentan brevemente
algunos de ellos [38].
UNO: Universal Network Objects
Es un modelo de componentes que ofrece interoperabilidad entre diferentes
lenguajes de programación, diferentes modelos de objetos, diferentes arquitecturas de
máquinas y diferentes procesos, tanto en una LAN o a través de Internet. Los productos de
SUN StarOffice y ONE WebTop han demostrado la utilidad de UNO en complejas
aplicaciones del mundo real. UNO es un sistema de libre disposición (se distribuye bajo la
licencia LGPL) y actualmente soporta Java, C y C++ (sobre Windows, Linux y Solaris).
UNO es desarrollado por la comunidad OpenOffice, que incluye a los laboratorios de
desarrollo de Sun MicroSystems.
XPCOM
Proviene de Cross Platform Component Object Model (Modelo de Componentes de
Objetos Multiplataforma), es un entorno para escribir software modular multiplataforma.
Como aplicación, XPCOM usa un conjunto de librerías centrales para cargar y manipular
selectivamente componentes XPCOM. Los componentes XPCOM pueden ser escritos en
C, C++ y JavaScript, con extensiones para Perl y Python que se encuentran en desarrollo.
Además de la modularidad, XPCOM ofrece una multiplataforma ágil. Soporta
prácticamente cualquier plataforma con un compilador de C++. A continuación se listan
algunas aplicaciones que utilizan XPCOM: Komodo (IDE), Chatzilla (IRC), Juegos
6
(MozInvaders, Xultris y otros), Jabberzilla (Mensajería instantánea), NS6 (El navegador de
Netscape), Mozilla (El navegador)
OpenDoc
Desarrollado originariamente por algunos de los líderes de la industria del software, es
una arquitectura de componentes de software orientada a objetos diseñada para acelerar el
desplazamiento de la industria desde las aplicaciones monolíticas hacia aplicaciones
orientadas a objetos más flexibles y modulares. OpenDoc, de IBM, ofrece una colección de
librerías de clases, con su código fuente, que pueden ser reutilizadas por desarrolladores de
C/C++. Actualmente IBM ha evolucionado su estrategia de componentes de software hacia
tecnologías de componentes Java y JavaBeans. A pesar de esto IBM, continúa ofreciendo
OpenDoc como software gratuito.
Entre los trabajos que tratan de forma directa, los procesos de búsqueda y selección de
componentes, están los siguientes:
1.
COTS-Based Requirements Engineering (CRE)
El método CRE propuesto por Alves [32], se desarrollo para facilitar el proceso de
selección y evaluación basado en los requisitos, prestando una especial atención al análisis
de los requisitos no funcionales [3]. La selección de componentes se realiza por rechazo, es
decir, los componentes candidatos que no cumplen alguno de los requisitos del cliente van
siendo rechazados y retirados de la lista de candidatos. Conforme esta lista va decreciendo,
es necesario aumentar el detalle de los requisitos. El resultado es un proceso iterativo
mediante el cual el proceso de adquisición de los requisitos permite la selección de
productos y, adicionalmente, el propio proceso de selección va obligando a generar
información para la obtención de requisitos requeridos.
2.
Off-The-Shelf Option (OTSO)
El método OTSO, desarrollado por Kontio [33], establece un proceso de selección
de “paquetes” de software reutilizables, denominados por los autores como OTS (Off-TheShelf), pues incluyen tanto componentes comerciales (COTS) como componentes
7
desarrollados internamente por las propias organizaciones [3]. El método OTSO facilita la
búsqueda, evaluación y selección de software reutilizables. Entre las fases o actividades que
identifican este método están, definición, búsqueda, filtrado, evaluación y análisis, donde se
van refinando los criterios de evaluación conforme avanza el proceso de selección. La fase
de búsqueda (search) tiene como meta identificar los potenciales candidatos que
posteriormente serán examinados. La fase de filtrado (screening) selecciona los candidatos
más prometedores, los que mejor cumplen con los requisitos de quien los solicita, que
pasarán a la fase de evaluación detallada. En la fase de análisis se consolidan los resultados
de las evaluaciones de los productos y se toma una decisión sobre la reutilización o no de
algún producto software.
3.
Procurement-Oriented Requirements Engineering (PORE)
El método PORE [34] es una propuesta basada en plantillas (templates) para
facilitar la captura de requisitos. Utiliza un proceso iterativo de captura de requisitos y de
selección y evaluación de componentes [3].
El ciclo de vida del modelo PORE tiene seis procesos genéricos. Estos procesos son
definidos a tres niveles de acuerdo a la clasificación propuesta en [39]: Nivel Universal,
Nivel Mundial y Nivel Atómico. Los seis procesos genéricos que PORE define a nivel
atómico son los siguientes:
Gestión del sistema: El objetivo de este proceso es la planificación del sistema.
Adquisición de requisitos: Este proceso obtiene y valida los requisitos de
calidad del usuario. Además, determina la arquitectura del sistema para que los
componentes puedan integrarse en él.
Selección de proveedores: Sus objetivos son establecer los criterios de selección
de los proveedores, evaluarlos, ordenarlos de acuerdo a esos criterios, y
seleccionar el que mejor se ajuste a ellos.
Selección de paquetes/componentes software: El objetivo de este proceso es
identificar los paquetes (componentes) candidatos, establecer los criterios de
selección usando los requisitos del cliente, evaluar los componentes
identificados, ordenarlos de acuerdo a los criterios, y seleccionar uno o más de
entre los que mejor cumplan el núcleo de requisitos esenciales del cliente.
8
Contrato de producción: Su objetivo es negociar los contratos legales con los
proveedores de los componentes de software, y resolver los aspectos legales
relativos a la compra y licencia de los mismos.
Aceptación del paquete/componente: El objetivo de este proceso es comprobar
que el paquete, componente o sistema, cumple con el núcleo original de
requisitos esenciales del cliente.
4.
A Search Architecture for Grid Software Components
Este motor de búsqueda [40], basado en técnicas de recuperación de información,
clasifica los componentes en base a: su semejanza con la descripción del requisito buscado,
su popularidad entre los desarrolladores, su uso dentro de otros servicios, etc.
Las especificaciones de este buscador dependerán del concepto de Ecosistema de
Componentes. El ecosistema provee un ambiente virtual a aplicaciones donde pueden vivir
(ser ejecutadas) y descubrir otros componentes, a los que pueden hacer referencia para
desarrollar componentes más grandes y complejos.
La idea de ecosistema puede ser fácilmente comparada con el concepto de la Web.
Bajo esta perspectiva un componente de software puede ser visto como una pagina Web,
una aplicación construida por composición de diferentes bloques, que a su vez, pueden ser
vistos en un sitio Web (una composición de diferentes páginas Web).
1.5.
Objetivos de la investigación
1.5.1. Objetivo general
Desarrollar un sistema de Selección de Componentes de Software Reutilizables
(CSR) utilizando Inteligencia Artificial Colectiva.
1.5.2. Objetivos específicos
Automatizar el proceso de selección de CSR.
9
Desarrollar algoritmos de Búsqueda y Selección de CSR basado en los Sistemas
de Hormigas Artificiales.
Demostrar que el criterio de selección de componentes utilizado por nuestro
sistema puede ser más fiable que otros criterios propuestos.
Comparar nuestro enfoque con otros trabajos o herramientas existentes.
10
CAPITULO ΙΙ
MARCO TEORICO
Para el desarrollo de la presente investigación, y el alcance de los objetivos
planteados, es necesario abordar las siguientes áreas de estudio, Inteligencia Artificial
Colectiva (IAC) e Ingeniería de software, específicamente en la sub-área de Componentes.
Los conceptos más relevantes son presentados a continuación.
2.1.
Inteligencia Artificial Colectiva (IAC):
Desde mucho tiempo, se ha venido estudiando, en una variedad de animales, un tipo
de conducta bastante interesante llamada “conducta colectiva” [31]. Ejemplos de esa
conducta es: una bandada de pájaros recorriendo el cielo, un grupo de hormigas en busca de
comida, etc. Recientemente, investigadores de la computación, específicamente en el
campo de “vida artificial” e “inteligencia colectiva”, han estudiado esa conducta,
particularmente cómo estos tipos de animales actúan recíprocamente, logran metas
colectivas y evolucionan [31]. La inteligencia colectiva (IC) ha sido aplicada en distintas
áreas como telecomunicaciones, robótica, trasporte, aplicaciones militares [21], etc. La idea
principal de IC sugiere que N agentes en una colonia cooperan mutuamente para lograr
alguna meta. Los agentes usan reglas simples para gobernar sus acciones, y por medio de
las interacciones del grupo entero logran sus objetivos. Un tipo de auto-organización surge
de la colección de acciones del grupo [21]. La IC resuelve problemas de manera flexible,
adaptativa y descentralizada. Esta definición incluye cualquier esfuerzo por diseñar
algoritmos o dispositivos para resolver problemas distribuidos, inspirado por conducta
colectiva de colonias de insectos sociales u otras sociedades de animales [22].
11
Algunas especies de hormigas, dejan rastros cuando se encuentran realizando
actividades de búsqueda, por ejemplo: cada una de las hormigas depositan una sustancia
química, llamada “feromona”, cuando se trasladan desde una fuente de alimento a su nido,
el resto de las hormigas siguen esta sustancia para encontrar el camino más eficaz a una
fuente de alimento. El proceso por el cual una hormiga es influenciada a ir hacia una
determinada fuente de alimento por otra hormiga, o por un sendero químico, es llamado
reclutamiento [22]. Cada hormiga puede ser considerada un agente [23]. En IC, los agentes
se ubican en grupos, llamados colonias, donde ellos hacen un trabajo cooperativo. Los
agentes procesan información, modulan su conducta de acuerdo a estímulos, y toman la
mejor decisión basada en la información del ambiente que les rodea. Pero el desafío más
grande es hacer que los agentes trabajen de manera colectiva, que integren sus actividades
individuales para generar resultados más complejos y eficaces.
La IC se ha usado de muchas diferentes maneras y ha inspirado técnicas como
optimización colectiva de partículas, optimización de colonias de hormigas, modelos
ecológicos, entre otros [31]. En los estudios actuales de IC, la conducta inteligente surge
frecuentemente a través de la comunicación indirecta entre los agentes [24].
Individualmente, las hormigas son insectos de comportamiento simple con memoria
limitada. Sin embargo, colectivamente las hormigas realizan tareas complicadas con un
grado alto de consistencia. Algunos ejemplos de comportamiento sofisticado de hormigas
son 1. Formación de puentes; 2. Construcción y mantenimiento de nidos; 3. Cooperación
al cargar objetos grandes; 4. Conseguir la ruta mas corta del nido a Fuentes de alimentos;
5. Regulación de temperatura del nido; etc. [24]. En los modelos estudiados se han
identificado dos tipos de comunicación indirecta, la primera involucra un cambio en las
características físicas del ambiente. La construcción del nido es un ejemplo de esta forma
de comunicación en que una hormiga observa el desarrollo de la estructura y agrega su
pelota de barro a la cima de él [24]. La segunda esta “basada en señales”. Aquí algo es
depositado en el ambiente que no hace ninguna contribución directa a la tarea, pero se usa
para influir en la conducta subsiguiente [24]. La comunicación indirecta basada en señales
esta muy desarrollada en las hormigas. Las hormigas usan un químico muy volátil llamado
“feromona” para proporcionar un sistema de señalización sofisticado.
12
Una hormiga aislada se mueve esencialmente al azar, pero una hormiga que
encuentra un sendero previamente transitado decidirá seguirlo con una probabilidad alta, y
así reforzarlo con una cantidad extensa de feromona. El comportamiento emergente
colectivo es una forma de comportamiento auto-catalítico en el cual mientras más hormigas
siguen una ruta, mas feromona se deposita y otras hormigas son más propensas a seguir la
misma ruta. Este proceso es caracterizado por un ciclo de retroalimentación positiva,
donde la probabilidad de que una hormiga escoja una ruta dada se incrementa a medida que
otras hormigas hayan hecho la misma selección anteriormente [24].
Uno de los principales trabajos en IC ha sido propuesto por Dorigo, Maniezzo and
Colorni [25]; ellos han propuesto un sistema artificial de hormigas e introducido tres tipos
de algoritmos hormigas [26]: Densidad de hormigas, Cantidad de hormigas, y ciclo de
hormigas, los cuales pueden ser usados para resolver diferentes problemas de optimización
combinatorial. Estos algoritmos, y extensiones a los mismos, han sido usados para resolver
la asignación cuadrática de problemas, el problema del viajero de comercio, problemas de
enrutamiento de vehículos [27], enrutamiento de redes orientado a conexión [28],
problemas de optimización combinatorial [29; 30], entre otros.
2.1.1. Formulas básicas del modelo
La regla de transición, es decir, la probabilidad de que una hormiga k vaya desde una
ciudad i a una ciudad j en el momento t es llamada regla de transición proporcional
aleatoria, y esta dada por:
p ij (t ) =
[τ
k
∑
][ ]
α
ij
(t ) . η ij
α
l∈J ik
β
[τ il (t )] .[ηil ]
β
, si j ∈ J ik , y 0 si j ∉ J ik
(2.1)
donde α y β son dos parámetros ajustables que controlan el peso relativo entre la intensidad
de la traza τ ij (t ) y la visibilidad η ij (es el inverso de la distancia entre las ciudades i y j).
J ik es el conjunto de las ciudades que la hormiga k puede visitar desde la ciudad i. Si α = 0
las ciudades más cercanas tendrán una alta probabilidad de ser seleccionadas: esto
13
corresponde al algoritmo clásico estocástico. Si, por el contrario β = 0, solo se considera la
feromona.
Después de completar la trayectoria, cada hormiga k deposita una cantidad de
feromona ∆τ ijk (t ) en cada camino (i, j) que ha transitado; el valor de ∆τ ijk (t ) depende de
que tan bueno ha sido el recorrido de la hormiga. En una iteración t (el contador de
iteraciones se incrementa en uno cuando todas las hormigas han completado una
trayectoria), la hormiga k deposita ∆τ ijk (t ) en un camino (i, j) transitado, como sigue:
Q / Lk (t )
∆τ (t ) = 
0
k
ij
si (i, j ) ∈ T k (t );
si (i, j ) ∉ T k (t );
(2.2)
Donde T k (t ) es la trayectoria seguida por la hormiga k en la iteración t, Lk (t ) es la
longitud, y Q es un parámetro (aunque el valor de Q influye poco en el resultado final,
debe asignársele un valor similar, en orden de magnitud, al de la longitud de la trayectoria
optima). Existen en la literatura otras expresiones matemáticas para calcular ∆τ ijk (t ) [26].
2.2.
Ingeniería de Software Basada en Componentes
2.2.1. Componente de software (CS)
Es una implementación de software que presenta una o más interfaces por medio de
las cuales ofrece su funcionalidad. Poseen un contenedor, el cual es parecido a un
envoltorio, que maneja los aspectos técnicos y los servicios de infraestructura del
componente [36] (ver Fig.2.1). La idea principal del uso de componentes es su reutilización
y su producción independiente, que permite su integración a diferentes desarrollos de
sistemas [15].
14
Fig. 2.1. Esquema de un Componente y su contenedor [36].
2.2.2. Arquitectura basada en componentes
El objetivo de la tecnología de componentes de software es construir aplicaciones
complejas, mediante ensamblado de módulos (componentes) que han sido previamente
diseñados por otros desarrolladores o empresas de software, a fin de ser reusados en
múltiples aplicaciones [12]. La arquitectura del software de una aplicación basada en
componentes, consiste en uno o un número pequeño de componentes específicos a la
aplicación (que se diseñan específicamente para ella), que hacen uso de otros muchos
componentes prefabricados que se ensamblan entre sí para proporcionar los servicios
que se necesitan en la aplicación [13].
Fig. 2.2. Arquitectura del software de una aplicación basada en componentes.
15
En la tecnología de componentes la interfaz constituye el elemento básico de
interconectividad. Cada componente debe describir de forma completa las interfaces que
ofrece, así como las interfaces que requiere para su operación. Además, debe operar
correctamente con independencia de los mecanismos internos que utilice para soportar la
funcionalidad de la interfaz.
Las características más relevantes de la tecnología de programación basada en
componentes son la modularidad, la reusabilidad y la componibilidad, y en todos ellos
coincide con la tecnología orientada a objetos [14], de la que se puede considerar una
evolución. Sin embargo, en la tecnología basada en componentes también se requiere
robustez, ya que los componentes han de operar en entornos mucho más heterogéneos y
diversos.
2.2.3. Características mas relevantes de los CS
Entre ellas están [44]:
Es autocontenido
Un componente no debe requerir la utilización de otros componentes para
cumplir su función.
Si el componente requiere de otros, el conjunto de componentes o funciones,
visto como un todo, debe ser considerado como un componente de más alto
nivel.
Es accesible solo a través de su interfaz
Es accedido a través de una interfaz claramente definida.
Determina las operaciones que el componente implementa como las que
precisa utilizar de otros componentes durante la ejecución.
Sus servicios son inmutables
Los servicios que ofrece un componente a través de su interfaz no deben
variar.
La implementación física de estos servicios pueden ser modificadas, pero no
deben afectar la interfaz.
16
Esta documentado
Debe tener una documentación adecuada que facilite:
La recuperación del componente desde el repositorio,
La evaluación del componente,
La adaptación al nuevo ambiente y
Su integración con otros componentes del sistema en que se utiliza.
Es reemplazable
Puede ser reemplazado por una nueva versión, o por otro componente que
proporcione los mismos servicios.
2.2.4. Modelos de componentes
El modelo define la forma de sus interfaces y los mecanismos para interconectarlos.
En la actualidad existen multitud de modelos de componentes definidos. A continuación
algunos de ellos:
Fractal
Es un modelo de componente flexible y extensible, desarrollado por el consorcio
ObjectWeb, que puede ser usado por diferentes lenguajes de programación para el diseño,
implementación, y configuración de sistemas y aplicaciones, como sistemas operativos,
middleware e interfaces graficas [41,42].
Este modelo usa tres características principales: separación de las interfaces y las
implementaciones, programación orientada a componentes, e inversión de control. El
primer aspecto, también denominado patrón de puente, corresponde a la separación entre
los aspectos de diseño e implementación. El segundo aspecto corresponde a la
implementación a partir de elementos pequeños, entidades bien separadas llamadas
componentes. El ultimo aspecto corresponde a la separación de las características
funcionales de las de configuración: en lugar de buscar los componentes y configurar los
recursos que ellos necesitan, los componentes FRACTAL son configurados y desplegados
por una entidad externa [41, 42].
17
JavaBeans
Un JavaBean o bean puede ser manipulado por una herramienta de programación en
lenguaje java. Para ello se define una interfaz en el momento del diseño, que permite a la
herramienta de programación, o IDE, conocer las propiedades que lo definen y los tipos de
respuestas que puede generar según diversos eventos [44]. Un javaBean puede variar en
cuanto a su funcionalidad, pero tipicamente unifica características, tales como [44]:
•
Soportan la introspección, es decir una herramienta de programación puede
analizar como trabaja un bean.
•
Soporta la configuración de su apariencia y comportamiento mediante la
utilización de alguna herramienta.
•
Soporta la persistencia, un bean puede ser configurado dentro de un constructor
de aplicaciones, manteniendo su configuración.
CORBA Component Model (CCM)
Para construir aplicaciones de nivel empresarial los desarrolladores deben integrar
su lógica de negocio en un entorno distribuido. Además, deben conseguir que estos
desarrollos sean flexibles y poco costosos de mantener. Esta claro que conseguir modelar,
diseñar e implementar este tipo de aplicaciones es muy complejo ya que hay que especificar
innumerables detalles que impiden que el desarrollo sea eficiente y rápido. Por ello se han
buscado patrones que permitan abstraernos de todos estos detalles y que solucionen las
complejidades que se escapan de la lógica de negocio. Gracias a estos patrones y junto con
herramientas de generación de código se pueden desarrollar componentes que se alojen en
servidores compuestos de estos patrones y que no necesitan ningún otro tipo de desarrollo.
El marco de la OMA (Object Management Arquitecture) que permite la definición,
generación, ensamblaje y despliegue de estos componentes se llama CORBA Component
Model [45]. EL CCM añade al lenguaje de definición de interfaces (IDL) la posibilidad de
definir componentes CORBA, y de describir los detalles de implementación de forma
suficiente como para permitir que el servidor se genere, se ensamble y se despliegue. Todo
el modelo de componentes CORBA tiene grandes similitudes con modelos existentes como
EJB y MTS, ya que de hecho, esta basado en ellos. Pero sigue la filosofía de estándar
18
abierto que le ha dotado de su gran importancia en el pasado y que los otros modelos no
siguen [45].
19
CAPITULO III
DISEÑO DEL ALGORITMO
En este capítulo se describe en forma detallada los distintos procesos que componen
el sistema el Sistema de Selección de Componentes de Software, y se explican las
características principales.
3.1
Generalidades
Se propone un algoritmo estocástico de selección de componentes de software
basado en inteligencia artificial colectiva, que permite seleccionar el mejor componente de
un grupo que cumple con especificaciones dadas. El algoritmo de selección está inspirado
en el uso de “trazas de feromona”, que permiten identificar a los mejores componentes a
utilizar a través de un proceso de retroalimentación positiva o negativa.
El sistema hará uso de un archivo que caracteriza a cada componente (perfil del
componente), que, entre otras cosas, especifica la calidad del mismo. En nuestro caso el
archivo tendrá un formato XML [15]. Este archivo contiene tanto información estática
como dinámica que describe aspectos funcionales y no funcionales del componente. Entre
la información estática se incluyen datos como, nombre, descripción, en la que se detalla
una breve reseña de la funcionalidad del componente, y cualquier otra información que sea
permanente en el tiempo. Entre el grupo de datos dinámicos se tiene información
relacionada a aspectos técnicos como las dependencias del componente, sistema operativo
donde ha sido usado y lenguaje de programación, y aspectos no funcionales como última
20
fecha de actualización, etc. Además, se incluye una variable que está asociada al
rendimiento del componente, llamada “feromona” (Ver Fig. 3.1.).
<componentStaticInformation>
<componentInformation>
<uniqueID>PRU0707</uniqueID>
<projectname>Database Of Our Owlish Wisdom</projectname>
<license>gpl</license>
<desc>
Database Of Our Owlish Wisdom is a knowledge
database, based on MySQL, and PHP4. It allows
one or more people to insert solutions, ideas or
whatever information they like. You can then
search for information in the database, to find
answers to various problems.
</desc>
</componentStaticInformation>
<profile1>
<pheromone>0.1</pheromone>
<location> www.cemisid.ula.ve/components/rmc </location>
<os>debian</os>
<dependency>string.dll - math.dll – proactive.jar –
fractal.jar - examples.jar
</dependency >
<ms>3</ms>
<et>0.01</et>
Fig. 3.1. Archivo de Perfil del Componente.
.
3.2.
Atributos a considerar en la caracterización de los componentes de software
Redefiniendo las características consideradas en [16] para la selección óptima de un
componente, generamos el perfil del componente (Ver Fig.3.1.). Cada componente podrá
tener un número indefinido de perfiles, cada uno representando el dominio donde dicho
componente puede ser usado, y tendrá un rendimiento relativo a este escenario de uso. Esto
permitirá tener una “traza” o marca para cada perfil (representada por la variable
“feromona” que anteriormente se menciono), que podrá incrementarse o decrementarse
según su rendimiento en dicho dominio (Ver Fig.3.2.).
21
Component
Profile 1
Profile 2
…
Profile n
Fig. 3.2. Modelo de Componente.
3.3.
Modelo de Selección
El sistema utilizará tantos agentes como desee, y cada uno deberá seleccionar todo
el grupo de componentes que el sistema a desarrollar requiere, las etapas que componen el
proceso de selección son las siguientes:
1. Cada agente realiza un recorrido por componente solicitado, independiente al seguido
por el resto de los agentes, en busca del componente.
1.1. La trayectoria seguida en cada recorrido consistirá en visitar, aleatoriamente, 1, 2 ó
n repositorios, que son los que contienen los componentes.
1.2. Al final de la trayectoria seguida, en cada uno de los recorridos realizados, el
agente habrá acumulado un grupo de componentes llamado cc, asociados al
componente relacionado al recorrido, candidatos a ser seleccionados.
2. Finalmente, cada agente realiza la selección del mejor componente encontrado, del
grupo de componentes cc conseguido, por componente solicitado.
El ensamblaje de los componentes estará a cargo del programador, luego de que cada
agente creado complete todo el proceso de selección y tenga a disposición todos los
componentes requeridos (Ver Fig. 3.3.). Dicho programador seleccionará, según algún
criterio, los componentes que requiere del grupo de componentes seleccionado por cada
agente, y los incorporará al sistema a desarrollar. Después, los agentes actualizaran la traza
de feromona de los componentes seleccionados por el programador.
22
Repositorio 1
Agente 1
Busca C*1
al C*n
C
C
C
Agente 2
Busca C*1
al C*n
Repositorio 2
C
Repositorio x
Agente m
Busca C*1
al C*n
C
C
C
C
C
Fig.3.3. Modelo de Selección. Cada agente busca el grupo de componentes a utilizar.
Las premisas generales para el modelo se muestran a continuación:
Suponemos que cada componente cuenta con un perfil que lo caracteriza.
Se asume que los requerimientos iniciales son perfectos y se tiene información
exacta de los componentes que se desean seleccionar. Esta información esta
asociada a un archivo XML, el cual agrupa la caracterización de los componentes.
La formula para establecer el grado de correspondencia entre el componente ideal y
el componente preseleccionado, viene dada por:
Xljui = 1 +
Hi
-
Nlju
(3.3)
donde Xljui es el grado de correspondencia entre el componente ideal i, y el componente j
con perfil u, ubicado en el repositorio l.
Hi identifica la sumatoria de las características
ideales que debe tener el perfil del componente i deseado, por ejemplo, sistema operativo,
lenguaje de programación, número máximo de dependencias, entre otras. Por otro
23
lado,
N representa la sumatoria de las características reales encontradas, similares a las
deseadas, del componente preseleccionado (candidato). Mientras más cercano a 1 sea el
valor de Xljui , mayor será la similitud entre las características ideales y las características
reales del componente j encontrado.
Cada agente evaluará un conjunto de componente de software, por cada componente
requerido, considerando [22; 29; 30; 35]:
1. El valor ideal de Xljui
es 1, el agente escogerá componentes cuya
correspondencia entre el componente deseado y el encontrado es cercana a ese
valor.
2. El monto de feromona Ylju (t) relacionado a cada componente j con perfil u,
ubicado en el repositorio l, que conforman cada uno de esos conjuntos, será
actualizado luego de que el usuario escoja los componentes a ensamblar en la
aplicación y los pruebe en ella. El monto se incrementará o decrecerá,
dependiendo del resultado de la evaluación del componente, y de la tasa de
evaporación de feromona.
La ecuación de transición que calcula la probabilidad de que un agente k seleccione
un componente j con perfil u, ubicado en el repositorio l, de entre un grupo ccik de posibles
componentes a seleccionar [1,2]:
ik
lju
P
(t ) = [Y
lju
][
(t ) X i lju
]
−1
∑ [Y
rsn
[
(t )] X
i
]
−1
rsn
(3.4)
rsn∈ccik
tal que ccik = {c rsn encontrados por el agente k, tal que,
∀ r = 1,...# repositorios, ∀ s = 1,...# componentes, ∀ n = 1,...# perfiles, X i rsn 
→1
}
Donde Ylju (t ) representa la cantidad de feromona para el componente j con perfil u
que ha sido encontrado por el agente k en el repositorio l. Los agentes son creados e inician
el proceso de selección al azar. Es importante notar que el valor de la probabilidad Pljuik (t )
24
pudiera ser diferente para dos agentes evaluando un mismo componente, ya que esta
depende del grupo de componentes ccik que cada agente ha encontrado.
Como se dijo anteriormente, cada agente k deposita una cantidad de feromona
∆Ylju (t ) en cada uno de los componentes conseguidos. Si ese agente es seleccionado por el
usuario, esa cantidad dependerá del rendimiento R que tiene el sistema donde el
componente es usado [1,2].
k
∆Ylju (t ) = (X lju
∗ Rlju ) −1
(3.5)
Tal que
Rlju = f (TE , M , NDlju )
(3.6)
La función de rendimiento ( Rlju ) viene dada por el Tiempo de Ejecución (TE ) del
sistema, la cantidad de memoria utilizada ( M ) , y el numero de dependencias ( NDlju ) que
el componente tiene. Si el rendimiento es bueno Rlju tiende a 1, de lo contrario es un
número grande.
En nuestra propuesta es necesario la retroalimentación positiva y negativa. Esta
última se hace a través de la tasa de evaporación de feromona, ya sea en el componente
seleccionado por el usuario o no. En general, la retroalimentación positiva y negativa es
realizada a través de la actualización de la traza como sigue [1,2]:
Ylju (t) = (1 – α) * Ylju (t) + ∆Yljuk (t )
(3.7)
El monto inicial de feromona de los componentes se asume como un número aleatorio. α
es una constante que controla la tasa de evaporación de feromona. Finalmente, para
determinar el componente “i” a seleccionar se define la siguiente regla de transición:
{ }
ik
arg max rsn∈ccik Prsn
S*ki = 
J (Valor Aleatorio)
(3.8)
25
ik
donde el valor de Prsn
viene dado por la Ec.(3.4). Así, S*ki es el componente i seleccionado
por el agente k de un grupo de componentes ccik ó, es un componente J seleccionado
aleatoriamente.
3.4.
Macro Algoritmo:
1. Definición e identificación de los componentes requeridos y sus respectivos perfiles
deseados.
2. Crear k agentes de selección
3. Cada agente realiza la selección de los componentes requeridos usando el
procedimiento “selección”.
4. Seleccionar un componente de entre la selección hecha por los distintos agentes,
ensamblar al sistema y ejecutarlo.
5. Actualizar la traza de feromona para cada perfil de componente de los distintos ccik .
Procedimiento “selección”:
1.
Repita desde i = 1 hasta n (n es el numero de componentes deseados)
1.1. Búsqueda de componentes similares al componente i requerido (estos
componentes conforman al conjunto ccik ).
1.2. Seleccionar uno de ellos usando (3.8).
26
CAPITULO IV
CONSTRUCCIÓN DEL SISTEMA
En esta etapa se describe detalladamente el diseño del sistema. Para ello hemos hecho
uso de los diagramas UML, considerando que la programación de nuestro sistema ha
sido desarrollada bajo la filosofía orientada a objetos.
4.1. Modelado Funcional del Sistema
4.1.1. Diagramas de casos de uso
Las siguientes figuras muestran los diagramas de casos de uso del sistema de
selección de componentes de software.
27
Selección de componentes de software
Solicitar
componentes
Usuario
Descripción
Fig.4.1. Diagrama que muestra el caso de uso solicitar componentes.
Tabla 1. Descripción del caso de uso Solicitar Componentes.
Actores:
Usuario.
Propósito:
Capturar la cantidad de componentes y agentes
(parámetros iniciales).
Resumen:
El usuario especifica el número de componentes que
solicita y la cantidad de agentes necesarios para atender
su solicitud.
Tabla 2. Descripción de la extensión Descripción.
Actores:
Usuario.
Propósito:
Capturar la descripción de cada uno de los
componentes requeridos.
Resumen:
El usuario especifica la descripción de cada
componente, esto incluye, palabras claves asociadas al
componente, así como también el perfil deseado.
28
El diagrama de la Fig.4.1 muestra como Descripción es una extensión del caso de
uso Solicitar Componentes.
Fig.4.2. Diagrama que muestra el caso de uso Seleccionar Componentes.
En la Fig.4.2 se puede apreciar el caso de uso Seleccionar Componentes, el cual
incluye Calcular Correspondencia, Calcular Probabilidad, y Visitar Repositorios.
Tabla 3. Descripción del caso de uso Seleccionar Componentes.
Actores:
Agente.
Propósito:
Conformar el grupo de los componentes solicitados.
Resumen:
El agente se encargará de seleccionar los mejores
componentes encontrados asociados a cada
componente requerido.
29
Tabla 4. Descripción de la extensión Visitar Repositorios.
Actores:
Agente.
Propósito:
Buscar los componentes solicitados.
Resumen:
El agente decide buscar en 1,2 ó n repositorios los
componentes requeridos por el usuario, formando
grupos de componentes encontrados por componente
requerido, candidatos a ser seleccionados por el agente.
Tabla 5. Descripción de la extensión Calcular Correspondencia.
Actores:
Agente.
Propósito:
Evaluar la semejanza entre un componente encontrado
y el deseado.
Resumen:
El agente calcula la correspondencia, entre un
componente deseado y el encontrado. La
correspondencia permite medir la semejanza entre las
características, funcionales y no funcionales, de un
componente solicitado y el encontrado.
Tabla 6. Descripción de la extensión Calcular Probabilidad de Selección.
Actores:
Agente.
Propósito:
Estimar la posibilidad de que el agente seleccione un
componente específico.
Resumen:
El agente calcula la probabilidad de seleccionar un
componente especifico, del grupo de componentes
encontrados, por componente solicitado.
30
Selección de componentes de software
Depositar Feromona
Actualizar Feromona
Agente
Calcular Tasa de
Evaporación de la Traza
Fig.4.3. Diagrama que muestra el caso de uso Actualizar Feromona.
La Fig.4.3 muestra como Depositar Feromona y Calcular Tasa de Evaporación de la
Traza están incluidos en el caso de uso Actualizar Feromona.
Tabla 7. Descripción del caso de uso Actualizar Feromona.
Actores:
Agente.
Propósito:
Modificar la traza de feromona.
Resumen:
El agente actualizara la traza de feromona,
incrementándola o decrementandola, dependiendo del
resultado de la evaluación del componente y de la tasa
de evaporación
31
Tabla 8. Descripción de la extensión Calcular Tasa de Evaporación de la Traza.
Actores:
Agente.
Propósito:
Realizar la retroalimentación negativa de la traza de
feromona.
Resumen:
El agente realiza la retroalimentación negativa, por
medio de la evaporación de la traza, al grupo de
componentes encontrados, por componente solicitado.
Tabla 9. Descripción de la extensión Depositar Feromona.
Actores:
Agente.
Propósito:
Realizar la retroalimentación positiva de la traza de
feromona.
Resumen:
Si un componente seleccionado por el agente, del
grupo de componentes seleccionados, es escogido por
el usuario, este agente deposita una cantidad
determinada de feromona en dicho componente
escogido.
4.1.2. Diagramas de actividades
A continuación se presenta una serie de diagramas que hacen referencia a las
actividades implicadas en los casos de uso estudiados.
32
Establecer pedido
Registra nro. de agentes
Registra nro. de comp. deseados
Establecer descripción de los comp.
Registra nombre de los comp. deseados
Registra caracteristicas deseadas de los comp.
Fig.4.4. Actividades generadas por caso de uso: Solicitar Componentes.
33
Cargar agentes
Buscar componentes solicitados
Calcular correspondencia
Calcular probabilidad de seleccionar un comp. encontrado
Seleccionar los comp. requeridos
Fig.4.5. Actividades generadas por casos de usos: Seleccionar Componentes.
34
Evaporar feromona en los comp. evaluados
Depositar feromona en los comp. seleccionados por el usuario
Mostar resultados
Fig.4.6. Actividades generadas por casos de usos: Actualizar Feromona.
La dinámica en el sistema de selección comienza cuando se especifican los
parámetros para establecer el pedido, es decir, el número deseado de componentes, y de los
agentes que atenderán la solicitud.
Una vez cumplida esta etapa, se procede a especificar los parámetros que
identifiquen a cada componente deseado. La descripción de los mismos consta del nombre
y características deseadas de cada componente solicitado (sistema operativo, lenguaje de
programación, etc) (ver Fig.4.4). Estas actividades descritas representan al caso de uso
Solicitar Componentes de Software.
Seguidamente, se deberán activar los agentes inicialmente asignados, para que
realicen el proceso de ubicar los componentes solicitados, calcular la correspondencia y la
probabilidad de seleccionar a los componentes encontrados, como se explica en el caso de
uso Seleccionar Componentes (ver Fig.4.5). Finalmente, se escogerán los componentes a
usar en el sistema y se actualizará la traza, evaporando feromona en todos los componentes
evaluados y depositando en aquellos que fueron escogidos, como se explica en el caso de
uso Actualizar Feromona (ver Fig.4.6), para luego mostrar los resultados obtenidos.
35
4.2.
El sistema programado
El diseño interno del sistema se muestra en las Fig.4.7 y 4.8, que contienen los
diagramas de componentes y de clases, respectivamente.
Fig.4.7. Diagrama de Componentes.
El objetivo de este diagrama es mostrar, además de los componentes o entidades de
software más relevantes del sistema, los aspectos relacionados a cada uno de ellos. A
continuación se detallan sus características:
Agente.exe: Es equivalente a la clase Agente. Su función consiste en ubicar los
componentes requeridos por el usuario y seleccionar a los mejores. Hace uso de
Componente.class, Repositorio1 y Repositorio2. Después de que cada agente
complete todo el proceso de selección y tenga a disposición todos los
componentes requeridos, muestra los resultados obtenidos como se puede ver en
la Fig.4.13.
36
Componente.class: Esta asociado a la clase Componente. Ofrece sus servicios
de evaluación de componentes a Agente.exe.
Repositorio1 y Repositorio2: Son los repositorios locales que son incorporados
para hacer las pruebas al sistema, estos almacenan los archivos XML que
contienen la información de los componentes que son ubicados y evaluados por
Agente.exe. Pueden haber mas repositorios, según el número de sitios
disponibles para buscar componentes.
perfilDeseado.xml: Archivo XML creado por la clase Perfil, en este se almacena
la información dada por el usuario, en cuanto a características deseadas en los
componentes que requiere.
perfilEncontrado.xml: Archivo XML que contiene la información de los
componentes que serán evaluados.
37
Fig.4.8. Diagrama de clases del diseño.
38
El diagrama de clases del diseño contiene las definiciones de las entidades del
software usadas por nuestro sistema, con las siguientes características:
BusquedaSeleccionComponente: Constituye el punto de partida del sistema. Es
la encargada de construir la primera ventana de interacción con el usuario (ver
Fig. 4.9.), la que permite a este último especificar los parámetros iniciales
(numero deseado de componentes y agentes). En su estructura están definidas
las clases DescripcionComponente y Agente. Una vez registrados los parámetros
iniciales, se encargara de llamar a la clase DescripcionComponente.
DescripcionComponente: Maneja todos los aspectos referentes a la descripción
de los componentes deseados por el usuario (nombres y características
deseadas). Para ello establece el formato que se observa en la Fig. 4.10. Hace
uso de la clase Perfil, que es la que le permite registrar las características
deseadas de los componentes en un archivo XML. Una vez registradas las
descripciones de cada uno de los componentes requeridos, esta clase ejecutara el
grupo de agentes asignados inicialmente para procesar la solicitud de
componentes.
Perfil: Define la estructura grafica (ver Fig. 4.11.) que permite al usuario
especificar las características deseadas en los componentes que requiere. Crea
los archivos XML que contendrán dicha información.
4.3
Descripción de la interfaz gráfica
Al entrar al sistema se presenta la interfaz inicial con el usuario, ella permite
especificar los parámetros iniciales (número deseado de componentes y agentes) como se
muestra en la Fig.4.9.
39
Fig. 4.9. Interfaz con el Usuario.
Una vez especificados los parámetros mencionados y presionado el botón aceptar,
inmediatamente se desplegará una segunda ventana de interacción con el usuario, como se
muestra en la Fig. 4.10. En caso contrario, de presionar el botón cancelar, el sistema
terminara su ejecución.
Fig. 4.10. Interfaz con el Usuario. Descripción de los Componentes.
Al llegar a este punto el usuario se encargará de especificar la descripción de cada
uno de los componentes que solicita, esto incluye, nombre o palabras claves, y perfil
deseado, asociado a cada componente, como se ve en la Fig. 4.10. Para anexar los perfiles
deseados el usuario deberá presionar el botón asociado al perfil del componente que desea
especificar. Seguidamente se presentara un dialogo (ver Fig. 4.11) que le permitirá
especificar características como: sistema operativo donde pueda ejecutarse, lenguaje de
40
programación utilizado para desarrollarlo, licencia y numero de dependencias asociadas a
él.
Fig. 4.11. Agregar Perfil Deseado.
En caso de presionar el botón aceptar (de la Fig. 4.10) sin antes completar la
descripción de su solicitud, se presentará un mensaje de error indicando el perfil deseado
del componente que aun no ha sido especificado (ver Fig. 4.12).
Fig.4.12. Dialogo informativo. El perfil deseado del componente 2 solicitado no ha sido
especificado.
En caso contrario, cada uno de los agentes se encargará de realizar la búsqueda y
selección del grupo de componentes de software requeridos. Los resultados serán
mostrados en una pantalla (ver Fig. 4.13). En esta última se puede observar, en un primer
plano los tres mejores perfiles encontrados por cada agente asociados a cada componente
requerido, junto con la probabilidad asociada a cada uno de ellos; y en un segundo plano, la
selección definitiva hecha por cada agente de cada componente requerido. Con esa
41
información, el usuario puede escoger los componentes que necesite para estructurar su
sistema.
Fig. 4.13. Ventana que muestra el resultado de la búsqueda y selección del grupo de
componentes de software hecha por cada agente.
42
CAPITULO V
PRUEBAS DEL SISTEMA
El presente capitulo esta dedicado a comprobar la funcionalidad y eficiencia del
sistema de selección de componentes desarrollado. Para ello, se procedió a realizar varios
experimentos y evaluar sus resultados, considerando nuestros criterios como una alternativa
diferente a las ya existentes, enfocado hacia una evaluación mas objetiva del componente
de software. Para eso, mostramos los resultados obtenidos con nuestro enfoque usando
nuestro criterio, y los que se obtendrían usando otros criterios, y en función de eso se da
discusión. Es bueno aclarar la independencia del algoritmo propuesto de la especificación
de criterios que se haga (podemos modificar el mismo).
5.1.
Criterios de selección de componentes más usados
Normalmente, los criterios de selección de componentes mas comúnmente usados
son los siguientes:
Popularidad
La popularidad se calcula de la siguiente manera [18]:
((registro de hits + URL hits) * (subscripciones + 1))^ (1/2)
donde:
registro de hits = numero de veces que la página del proyecto (componente de
software) es accedida desde Freshmeat.net ó Sourceforge.net.
URL hits = indica las veces que el URL, asociado a la página del proyecto es
accedido desde fuera del Freshmeat.net ó Sourceforge.net.
43
Subscripciones = número de subscripciones que tiene el proyecto.
Rating
Cada usuario registrado, ya sea en freshmeat.net ó sourceforge.net, puede
categorizar u opinar sobre un proyecto (componente de software) en particular ofrecido por
estos repositorios. Basado en estas categorizaciones y opiniones, estos sitios Web
construyen una lista de los 20 proyectos de software con mejor categorización. Cada
proyecto es evaluado por medio de la siguiente formula [18]:
(WR) = (v ÷ (v+m)) × r + (m ÷ (v+m)) × C
donde:
WR = peso o relevancia obtenida por el proyecto.
r = promedio del proyecto (clasificación o rating) = cada usuario registrado califica
un proyecto, dentro de un rango de puntuación determinado, (r) representa el promedio de
la calificación obtenida.
5.2.
v
= numero de votos que tiene el proyecto.
m
= votos mínimos requeridos que debe alcanzar un proyecto para ser incluido.
C
= promedio de votos en el sistema por proyecto.
Descripción de los experimentos
Como se ha dicho antes, las pruebas serán hechas utilizando 2 repositorios locales
de perfiles de componentes (Repositorio 1 y Repositorio 2). Ambos contienen información
relacionada a los repositorios Freshmeat.net y Sourceforge.net, respectivamente.
La variable R descrita en el Capitulo III, formula (3.6), y que esta asociada al
rendimiento del sistema donde los componentes escogidos son usados, se asume como un
número aleatorio para poder efectuar las pruebas.
A continuación se presenta los experimentos realizados.
44
5.2.1. Experimento 1
Se procedió a ejecutar el sistema, en 4 oportunidades consecutivas, variando el
número de agentes, manteniendo en 2 el número de componentes requeridos. Para dichos
componentes se desearon las características que se pueden ver en la tabla 10.
Tabla 10. Descripción de los componentes requeridos.
Componente 1 (C1)
Componente 2 (C2)
Nombre/Identificador: Library string
Nombre/Identificador: Text editor
Sistema operativo: Windows
Sistema operativo: Linux
Lenguaje de programación: Basic
Lenguaje de programación: C++
Licencia: General Public Licence
Licencia: General Public Licence
Nro. De dependencias: 3
Nro. De dependencias: 6
El componente 1 C1 se refiere a una librería para el manejo de cadenas, y el C2, a
un editor de texto. Los nombres o identificadores de los componentes requeridos se
especifican en ingles debido a que los archivos XML que contienen la descripción de ellos
están escritos en ese idioma. El orden de ejecución del sistema, junto con los parámetros
asignados en cada caso, es el que se puede ver en la tabla 11.
Tabla 11. Orden de ejecución del sistema.
Numero de agentes
Numero de componentes
Primera corrida
1
2
Segunda corrida
2
2
Tercera corrida
3
2
Cuarta corrida
10
2
45
5.2.2. Experimento 2
En este experimento, se procedió a ejecutar el sistema desarrollado, en tres
oportunidades consecutivas, solicitando una cantidad constante de componentes, en este
caso 8, variando la cantidad de agentes. Los componentes solicitados, junto con las
características deseadas, se muestran en la tabla 12.
Tabla 12. Descripción de los componentes requeridos.
Componente 1 (C1)
Componente 2 (2)
Nombre/Identificador: Library math
Nombre/Identificador: Multiplication
Sistema operativo: Solaris
Sistema operativo: Linux
Lenguaje de programación: Php
Lenguaje de programación: Php
Licencia: Mozilla Public License
Licencia: The Apache License
Nro. De dependencias: 0
Nro. De dependencias: 2
Componente 3 (3)
Componente 4 (4)
Nombre/Identificador: Sum
Nombre/Identificador: Manager database
Sistema operativo: Windows
Sistema operativo: Windows
Lenguaje de programación: C
Lenguaje de programación: Basic
Licencia: General Public License
Licencia: General Public License
Nro. De dependencias: 1
Nro. De dependencias: 4
Componente 5 (5)
Componente 6 (6)
Nombre/Identificador: Text editor
Nombre/Identificador: Finder of pictures
Sistema operativo: Linux
Sistema operativo: Solaris
Lenguaje de programación: C++
Lenguaje de programación: Java
Licencia: General Public License
Licencia: Shareware
Nro. De dependencias: 4
Nro. De dependencias: 0
Componente 7 (C7)
Nombre/Identificador: Library string
Componente 8 (C8)
Nombre/Identificador: Calculator
46
Sistema operativo: Solaris
Sistema operativo: Linux
Lenguaje de programación: Java
Lenguaje de programación: Php
Licencia: Shareware
Licencia: General Public License
Nro. De dependencias: 0
Nro. De dependencias: 3
Cada componente requerido se refiere a: C1 una librería para el manejo de operaciones
matemáticas, C2, solicitado para efectuar multiplicaciones matemáticas, C3 para sumas,
C4 un manejador de base de datos, C5 un editor de texto, C6 un visor de imágenes, C7
una librería para el manejo de cadenas de caracteres, y, C8 para efectuar operaciones
matemáticas. La ejecución fue como sigue:
Tabla 13. Orden de ejecución del sistema.
5.3.
Numero de agentes
Numero de componentes
Primera corrida
1
8
Segunda corrida
2
8
Tercera corrida
10
8
Análisis de los resultados
Antes de presentar los resultados obtenidos, a continuación se describe la
nomenclatura utilizada:
Per/Prob/Ri = Indica el perfil (Per) seleccionado por el agente junto con la
probabilidad (Prob) de selección, y el repositorio (Ri) donde fue ubicado.
Per/Pop/Ri = Indica la popularidad (Pop) del perfil (Per) señalado. Ri es el
repositorio donde se ubica.
Per/Rat/Ri = Indica el rating (Rat) del perfil (Per) señalado. Ri es el repositorio
donde se ubica.
47
Antes de entrar en detalle, es de importancia saber que además de los experimentos
que a continuación se detallan, previamente se realizaron pruebas para comprobar el
comportamiento esperado en los agentes, es decir, que su comportamiento fuera acorde a lo
establecido en el diseño de nuestro algoritmo de selección, y así saber que no se cuenta con
fallas funcionales en el sistema. En estas pruebas, a diferencia de las otras, se establecieron
los perfiles de componentes de software deseados (especificaciones técnicas y funcionales),
y se identificaron su presencia en algunos de los reposirorios. Después, se inicio el proceso
de búsqueda con nuestro algoritmo. Al final del proceso de búsqueda se constato si los
perfiles seleccionados por el algoritmo (agentes) fueran los mejores (ideales) previamente
identificados por nosotros. Esto nos permitió comprobar si el algoritmo siguió el
comportamiento esperado.
5.3.1. Experimento 1
Los resultados obtenidos se muestran en el apéndice, tablas de resultados del
experimento 1. Las tablas muestran, por corrida o ejecución del sistema, los cinco mejores
perfiles encontrados de acuerdo al criterio de probabilidad, popularidad y rating, asociados
a cada componente requerido, y el repositorio de donde provienen. Esto permitirá comparar
el criterio de escogencia utilizado por los agentes junto con los otros dos criterios. Los
valores obtenidos de popularidad y rating son características que vienen incluidas en cada
uno de los perfiles de los componentes evaluados.
Comenzando ya con el análisis, al observar los resultados obtenidos en la primera
corrida (ver tabla 14), resalta el hecho de que el mejor perfil encontrado por el agente 1
(44/0.466/2), asociado al C1, no figura entre los cinco más populares. Esto indica que no
siempre es cierto que el componente más popular es el que va a cumplir con los requisitos
iniciales del usuario (funcionales y no funcionales), teniendo en cuenta que estos requisitos
mencionados son evaluados por los agentes, en los componentes encontrados. Además,
nuestros agentes también consideran el factor de desempeño, el cual es evaluado por medio
de la cantidad de feromona asociada al componente. Entre más feromona mejor es el
rendimiento del componente. Así, un componente popular tampoco significa que tenga un
buen desempeño. Aunque es bueno resaltar que el perfil con mejor popularidad es el tercero
48
mejor encontrado por el agente 1, de entre un grupo aproximadamente de 15 componentes
evaluados. Esta es una ventaja que tiene el algoritmo propuesto en esta investigación, el
cual ofrece distintas alternativas al usuario, quien al final tendrá la última palabra al
momento de realizar la escogencia de los componentes. Por otro lado, el mejor perfil
encontrado por el agente 1 (44/0.466/2) es el quinto con mejor rating, lo que igualmente
comprueba que un componente con buen rating no indica que tenga un buen desempeño o
cumpla con los requisitos iniciales del usuario.
Algo similar ocurre con los resultados obtenidos, en la misma primera corrida,
asociados al C2. El mejor perfil encontrado por el agente 1 (109/0.144/1) no figura entre los
cinco más populares y de mejor rating. Esto es perfectamente posible por las circunstancias
anteriormente explicadas. Situación completamente contraria ocurre con los resultados que
presenta el agente 2, asociados al C2, de la segunda corrida (ver tabla 15), donde el perfil
(109/0.6592/1) además de ser el mejor encontrado por el agente, es el más popular y el que
tiene el mejor rating.
Otra característica que se observa en el sistema de selección propuesto es el hecho
de que varios agentes, relacionados a una misma corrida, presentan resultados similares en
la evaluación de los componentes encontrados. Tal es el caso de los agentes 1 y 2 de la
segunda corrida (ver tabla 15), los cuales obtuvieron los mismos resultados asociados al
C1. Esto es debido a que ambos siguieron una misma ruta de búsqueda del componente
solicitado, situación posible ya que los agentes actúan de manera autónoma al decidir en
qué o en cuáles repositorios buscar los componentes solicitados. Algo importante para
resaltar es que los agentes 2 y 3 de la tercera corrida (ver tabla 16) y el agente 5 de la cuarta
corrida (ver tabla 17), respectivamente, visitaron solo un repositorio (en este caso
Repositorio 2) para buscar al C1, formando un mismo grupo de componentes encontrados.
Sin embargo, los resultados obtenidos de la evaluación hecha por estos agentes sobre este
grupo de componentes difieren entre las corridas, debido a que al finalizar un proceso de
búsqueda y selección en una corrida del programa todos los componentes evaluados,
relacionados a los componentes requeridos, son sometidos al proceso de evaporación de su
traza de feromona, y, los componentes escogidos, de entre la selección hecha por los
agentes para ensamblar al sistema a desarrollar, reciben una cierta cantidad de feromona
que dependerá del rendimiento (R) que ellos tengan en el sistema donde son ensamblados.
49
Esta actualización de feromona es lo que incide en que los resultados obtenidos sean
distintos.
5.3.2. Experimento 2
Los resultados obtenidos en el experimento 2 se muestran en el apéndice. Dichos
resultados demuestran que el comportamiento de los agentes, observado en el experimento
1, es consistente en este experimento, a pesar del aumento en el sistema del número de
componentes solicitados. En ambos experimentos se observa un contraste en cuanto a
componentes solicitados, es decir en el experimento 1 se solicitan solo 2 y en el segundo
experimento hasta 8 componentes son solicitados. Situación como la que se ve en la
primera corrida relacionada a este experimento (ver tabla 18) le da al usuario la idea de
cómo debe ser usado el sistema. Se puede apreciar, a pesar de que solo están disponibles 2
repositorios, que un solo agente por lo general no es suficiente para buscar 8 componentes
distintos requeridos. En ese caso se observa que la mayoría de los componentes solicitados
fueron buscados en un solo repositorio, descartando las demás opciones de búsqueda. Caso
contrario ocurre en la tercera corrida de este experimento (ver tablas 20 y 21), donde al
tener una cantidad adecuada de agentes se garantizan búsquedas diversas que permitan
encontrar a los mejores componentes, según la solicitud hecha. También, en esta ultima
corrida se puede apreciar que el C8 requerido fue hallado por unos agentes y por otros no,
lo cual indica que existe en uno de los 2 repositorios disponibles. Por otro lado, el C6 no
fue hallado por ninguno de los agentes.
50
CONCLUSIONES
Luego de realizar la investigación se llego a las siguientes conclusiones:
Se logro el objetivo principal al desarrollar un sistema que selecciona
componentes de software, inspirado en la conducta colectiva de las hormigas,
específicamente en el uso de trazas de feromona. Con el desarrollo de este
sistema se ha contribuido a la automatización de los procesos de búsqueda y
selección de componentes de software.
Se comprobó el hecho de que no siempre los criterios de selección de
componentes mas comúnmente usados (popularidad y rating) son los más
eficaces. Esto lo deducimos porque la selección hecha por los agentes se basa en
los requisitos iniciales del usuario y el desempeño de los componentes, y los
resultados obtenidos por ellos difieren de los obtenidos usando los criterios de
popularidad rating.
Para determinar un número idóneo de agentes en el sistema, debe ser tomado en
cuenta tanto la cantidad de componentes requeridos como de repositorios a ser
considerados. Es decir, el número de agentes a usar debe garantizar conseguir
todos los componentes solicitados, buscándolos a través de todos los
repositorios disponibles, esto permitiría obtener mejores resultados.
El sistema desarrollado se puede utilizar para fortalecer los procesos
relacionados a la Fábrica de Software Libre de Fundacite, que involucren la
búsqueda de componentes de software.
51
Puede ser utilizado no solo para la selección de componentes de software, sino
también para la selección de servicios, recursos etc., pues es lo suficientemente
general para ser replicado según requerimientos particulares.
52
RECOMENDACIONES
Incorporar otros repositorios de componentes y hacer más pruebas al sistema para
observar su comportamiento.
53
BIBLIOGRAFÍA
1. Bonabeau Eric, Dorigo Marco, Theraulaz Guy. Swarm Intelligence. From Natural
to Artificial Systems. Oxford University Press. 1999.
2. Jose Aguilar.
The Combinatorial Ant System for Dynamic Combinatorial
Optimization Problems. CEMISID. Computer Science Department. Universidad de
Los Andes. Technical Report.
3. Manuel F. Bertoa, José M. Troya y Antonio Vallecillo. Aspectos de calidad en el
desarrollo de software basado en componentes. Universidad de Málaga.
4. A. Vallecillo, J. Hernández, and J.M. Troya. “Object Interoperability.” In
ECOOP’99 Workshop Reader, LNCS 1743, pp. 1-21. Springer-Verlag, 1999.
5. Chung, L., Nixon, B., Yu, E., and Mylopoulos, J., “Non-Functional Requirements in
Software Engineering”. Kluwer Academic Publisher, 2000.
6. N. Rosa, C. Alves, P. Cunha, J. Castro and G. Justo. “Using Non-Functional
Requirements to Select Components: A Formal Approach.” In Proceedings of
IDEAS’01, San José, Costa Rica. April 2001.
7. Maribel Ariza Rojas, Juan Carlos Molina García. Introducción y principios básicos
del desarrollo de software basado en componentes. Septiembre 30 de 2004.
8. Rebeca P. Díaz Redondo, José J. Pazos Arias. Reutilización de requisitos
funcionales de sistemas distribuidos utilizando técnicas de descripción formal.
Febrero de 2002.
9. Pressman Roger S. “Ingeniería del Software. Un Enfoque Practico”. McGrawHill,
Cuarta Edición. 1997.
10. Billy Reinoso Carlos. “ Introducción a la Arquitectura de Software”. Versión 1.0
Marzo 2004. Universidad de Buenos Aires Argentina.
57
11. Garcia Serrano Ana, Ossowski Sascha, “Inteligencia Artificial Distribuida y
Sistemas Multiagentes”. Revista Iberoamericana de Inteligencia Artificial. Número
6 - Otoño / 98. Universidad Politecnica de Madrid, Universidad Juan Carlos de
Madrid.
12. Szyperski C.: “Component Software: Beyond Object-Oriented Programming”
Addison- Wesley, 1999.
13. Medina J.L. y Drake J.M.: “Modelado y Análisis de Tiempo Real de Aplicaciones
Basadas en Componentes” V Jornadas de Tiempo Real. Cartagena , 2002.
14. Pedro Javier Espeso Martínez. Diseño de componentes software de tiempo real.
Diciembre de 2002.
15. Dellarocas Chrysanthos. Software Component Interconection Should be Treated as
a Distinct Design Problem. MIT. Technical Report.
16. Asunción Gómez Pérez, Adolfo Lozano. Impact of Software Components
17. Characteristics above decisión-making Factors.
18. Search Engine, http://freshmeat.net, Accessed in 12/Oct/2005.
19. Rebeca P. Días Redondo, José J. Pazos Arias. Reutilización de requisitos
funcionales de sistemas distribuidos utilizando técnicas de descripción formal.
20. Blanca Abraham Z. Arquitectura inteligente de desarrollo de software.
21. Liu Y, Passino K. Swarm Intelligence: Literature Overview. Department of
Electrical Engineering. The Ohio State University. Literature Overview. March
2000.
22. Bonabeau E, Dorigo M, Theraulaz G. Swarm Intelligence. From Natural to
Artificial Systems. Oxford University Press. 1999.
23. Wooldridge, J.P. Muller, M. Tambe (eds.). Assistant Agents that Distribute HowTo-Do Knowledge. Intelligent Agents II. Lecture Notes in AI, Volume 1037.
pages408-411. Springer-Verlag, 1996.
24. Random J. Swarm Intelligence and Problem Solving in Telecommunications.
Canadian Artificial Intelligence Magazine. 1997. N. 41. p. 14-16.
25. Dorigo M., Maniezzo, V., and Colorni, A., 1991, Positive Feedback as a Search
Strategy. Technical Report No. 91-016, Politecnico di Milano, Italy.
58
26. Krishnaiyer K, Hossein S. (2002). Ant Algorithms: Review and Future
Applications, Industrial Engineering Research Conference (IERC´02), Orlando,
Florida, USA, May 2002.
27. Bullnheimer B, Hartl R and Strauss C. "Applying the Ant System to the Vehicle
Routing Problem". Paper presented at 2nd International Conference on
Metaheuristics, Sophia-Antipolis, France. 1997.
28. Aguilar J. (2004). A New Swarm Intelligence Approach for Routing Algorithms.
XIII Congreso Internacional de Computación, (CIC 2004) Mexico City, Mexico.
29. Aguilar J.
The Combinatorial Ant System for Dynamic Combinatorial
Optimization Problems. Revista de Matemática: Teoría y Aplicaciones, Vol. 12,
No. 1&2, pp. 51-60, 2005.
30. Aguilar J, Velasquez L, Pool M. "The Combinatorial Ant System", Applied
Artificial Intelligence, Taylor and Francis, Vol. 18, N. 5, pp. 427-446, 2004.
31. Abraham Blanca, Aguilar Jose. Software Component Selection Algorithm Based on
Artificial Ant Systems.
32. C. Alves and J. Castro. “Um Método Baseado em Requisitos para Seleção de
COTS” 4th Iberoamerican Workshop on Software Engineering and Software
Environment (IDEAS’01) San Jose, Costa Rica, April 2001.
33. J. Kontio, S. Chen, K. Limperos, R. Tesoreiro, G. Caldeira, and M.S. Deutsch, “A
COTS Selection Method and Experience of Its Use”. In Proceeding of the 20th
annual Software Engineering Workshop. NASA. Greenbelt, Maryland. November
1995.
34. C. Ncube and N. Maiden. “M PORE: Procurement-Oriented Requirements
Engineering Method for the Component-Based Systems Engineering Development
Paradigm”. International Workshop on Component-Based Software Engineering,
May 1999.
35. Aguilar J, Labrador M, "An Ant System-based Routing Algorithm for Sensor
Networks", Lecture Series on Computer and Computational Sciences, Brill
Academic Publishers, Volume 1, pp. 1-3, 2005.
36. A. M. Reina, J. Torres. Components + Aspects: A General Overview. Revista
Colombiana de Computación. Volumen 5 Numero 1.
59
37. Ingenieria del software basada en componentes.
38. http://www.aditel.org/jornadas/02/ponencias/bonobo/bonobo-doc/sistemas-libres
39. W.S. Humphrey. “Managing the Software Process”. Addison-Wesley, 1989.
40. Diego Puppin, Fabrizio Silvestri, Domenico Laforenza, Salvatore Orlando. A
Search Architecture For Grid Software Components.
41. Baude Francoise, Caromel Denis, Matthieu Morel. On Hierarchical, Parallel and
Distributed Components for Grid Programming.
42. Objectweb. FRACTAL Project. http://fractal.objectweb.org/tutorial/index.html
43. Julio A. Hurtado A, Lina M. Castillo P. Desarrollo de Software Basado en
Componentes en la Plataforma J2EE. Facultad de Ingenieria Electrónica y
Telecomunicaciones, Universidad del Cauca, Popayán, Colombia.
44. Vanesa Hamar, Jonas Montilva. Aspectos metodológicos del desarrollo y
reutilización de componentes de software. Mérida-Noviembre 2003.
45. Alberto C. Cárcamo. Ventajas del desarrollo basado en componentes con CCM.
Universidad Pontificia de Salamanca, Dept. Lenguajes y Sistemas. Madrid, España,
28028.
60
APÉNDICE. TABLAS
DE RESULTADOS
57
1. Experimento 1
Agente 1
Agente 1
Tabla 14. Primera corrida
C1
C2
Per/Prob/Ri
Per/Pop/Ri
Per/Rat/Ri Per/Prob/Ri Per/Pop/Ri
Per/Rat/Ri
44/0.466/2
37/107503/2
35/98.74/2 109/0.144/1 90/28942/2 94/99.71/2
41/0.274/2
40/49870/2
43/92.79/2 101/0.125/1 88/27756/2 87/98.82/2
37/0.064/2
38/48533/2
41/92.73/2
86/0.104/2 86/23005/2 91/94.72/2
43/0.049/2
39/43707/2
36/87.97/2
85/0.096/2 89/12090/2 92/93.69/2
39/0.032/2
42/41791/2
44/86.57/2 100/0.078/1 92/9620/2
93/93.69/2
Tabla 15. Segunda corrida
C1
Per/Prob/Ri Per/Pop/Ri Per/Rat/Ri Per/Prob/Ri
C2
Per/Pop/Ri
Per/Rat/Ri
40/0.3051/2 37/107503/2 35/98.74/2
93/0.3183/2
90/28942/2
94/99.71/2
41/0.2658/2 40/49870/2 43/92.79/2
86/0.2616/2
88/27756/2
87/98.82/2
44/0.1369/2 38/48533/2 41/92.73/2
85/0.2025/2
86/23005/2
91/94.72/2
39/0.0769/2 39/43707/2 36/87.97/2
87/0.0685/2
89/12090/2
92/93.69/2
37/0.0445/1 42/41791/2 44/86.57/2
94/0.0509/2
92/9620/2
93/93.69/2
Agente 2
40/0.3051/2 37/107503/2 35/98.74/2 109/0.6592/1 109/3583.8/1 109/8.71/1
41/0.2658/2 40/49870/2 43/92.79/2 108/0.1157/1 100/683.82/1 81/8.31/1
44/0.1369/2 38/48533/2 41/92.73/2 102/0.0662/1
81/677.95/1
101/8.2/1
39/0.0769/2 39/43707/2 36/87.97/2 104/0.02968/1 101/303.53/1
98/0.0/1
37/0.0445/1 42/41791/2 44/86.57/2 100/0.0198/1 110/262.58/1
99/0.0/1
Agente 1
Tabla 16. Tercera corrida
Per/Prob/Ri
C2
Per/Pop/Ri
Per/Rat/Ri
38/0.5347/1 37/107503/2 35/98.74/2 85/0.7744/2
90/28942/2
85/99.76/2
39/0.1495/2
88/27756/2
94/99.71/2
Per/Prob/Ri
C1
Per/Pop/Ri
Per/Rat/Ri
40/49870/2 43/92.79/2 90/0.2098/2
58
37/0.0475/1 38/48533/2 41/92.73/2
94/0.0079/2 86/23005/2
87/98.82/2
36/0.0468/1 39/43707/2 36/87.97/2
89/0.0016/2 89/12090/2
91/94.72/2
43/0.0276/2
42/41792/2 44/86.57/2 91/0.0011/2
92/9620/2
92/93.69/2
Agente 2
39/0.5518/2 37/107503/2 35/98.74/2 107/0.2334/1 109/3583.8/1 109/8.71/1
43/0.1021/2
40/49870/2 43/92.79/2 108/0.1436/1 100/683.82/1 81/8.31/1
38/0.0950/2
38/48533/2 41/92.73/2 112/0.1265/1 81/677.95/1
101/8.2/1
37/0.0711/2
39/43707/2 36/87.97/2 81/0.0995/1 101/303.53/1
98/0.0/1
Agente 3
40/0.0457/2
42/41792
44/86.57/2 111/0.0896/1 110/262.58/1
99/0.0/1
39/0.5518/2 37/107503/2 35/98.74/2 85/0.7453/2
90/28942/2
94/99.71/2
43/0.1021/2
40/49870/2 43/92.79/2 90/0.2020/2
88/27756/2
87/98.82/2
38/0.0950/2
38/48533/2 41/92.73/2 107/0.0087/1 86/23005/2
91/94.72/2
37/0.0711/2
39/43707/2 36/87.97/2 94/0.0076/2
89/12090/2
92/93.69/2
40/0.0457/2
42/41791/2 44/86.57/2 108/0.0053/1
92/9620/2
93/93.69/2
Per/Rat/Ri
Agente 3
Agente 2
Agente 1
Tabla 17. Cuarta corrida
C1
Per/Prob/Ri Per/Pop/Ri
Per/Rat/Ri
Per/Prob/Ri
C2
Per/Pop/Ri
38/0.7201/1 45/1100.9/1
37/8.32/1
90/0.5787/2
90/28942/2
94/99.71/2
36/0.0888/1 38/780.6/1
38/8.11/1
85/0.3044/2
88/27756/2
87/98.82/2
45/0.0723/1 37/395.36/1
45/8.11/1
94/0.0509/2
86/23005/2
91/94.72/2
39/0.0278/1 41/331.76/1
35/8.09/1
89/0.0296/2
89/12090/2
92/93.69/2
37/0.0265/1 44/227.61/1
42/8.02/1
88/0.0088/2
92/9620/2
93/93.69/2
38/0.7201/1 45/1100.9/1
37/8.32/1
90/0.4955/2
90/28942/2
94/99.71/2
36/0.0888/1 38/780.6/1
38/8.11/1
85/0.2606/2
88/27756/2
87/98.82/2
45/0.0723/1 37/395.36/1
45/8.11/1
94/0.0436/2
86/23005/2
91/94.72/2
39/0.0278/1 41/331.76/1
35/8.09/1
89/0.0253/2
89/12090/2
92/93.69/2
37/0.0265/1 44/227.61/1
42/8.02/1 107/0.0246/1
92/9620/2
93/93.69/2
40/0.3349/2 37/107503/2 35/98.74/2 90/0.4955/2
90/28942/2
94/99.71/2
41/0.2666/2 40/49870/2 43/92.79/2 85/0.2606/2
88/27756/2
87/98.82/2
36/0.1451/2 38/48533/2 41/92.73/2 94/0.0436/2
86/23005/2
91/94.72/2
59
35/0.1391/2 39/43707/2 36/87.97/2 89/0.0253/2
89/12090/2
92/93.69/2
39/0.1391/2 42/41791/2 44/86.57/2 107/0.0246/1
92/9620/2
93/93.69/2
Agente 5
Agente 4
38/0.4044/1 37/107503/2 35/98.74/2 107/0.1711/1 109/3583.8/1 109/8.71/1
40/0.1468/2 40/49870/2 43/92.79/2 100/0.1485/1 100/683.82/1 81/8.31/1
41/0.1169/2 38/48533/2 41/92.73/2 81/0.1219/1
81/677.95/1
101/8.2/1
36/0.0636/2 39/43707/2 36/87.97/2 102/0.0951/1 101/303.53/1
98/0.0/1
35/0.0610/2 42/41791/2 44/86.57/2 108/0.0948/1 110/262.58/1
99/0.0/1
40/0.3349/2 37/107503/2 35/98.74/2 90/0.5787/2
90/28942/2
94/99.71/2
41/0.2666/2 40/49870/2 43/92.79/2 85/0.3044/2
88/27756/2
87/98.82/2
36/0.1451/2 38/48533/2 41/92.73/2 94/0.0509/2
86/23005/2
91/94.72/2
35/0.1391/2 39/43707/2 36/87.97/2 89/0.0296/2
89/12090/2
92/93.69/2
39/0.1391/2 42/41791/2 44/86.57/2 88/0.0088/2
92/9620/2
93/93.69/2
Agente 9
Agente 8
Agente 7
Agente 6
38/0.4044/1 37/107503/2 35/98.74/2 107/0.1711/1 109/3583.8/1 109/8.71/1
40/0.1468/2 40/49870/2 43/92.79/2 100/0.1485/1 100/683.82/1 81/8.31/1
41/0.1169/2 38/48533/2 41/92.73/2 81/0.1219/1
81/677.95/1
101/8.2/1
36/0.0636/2 39/43707/2 36/87.97/2 102/0.0951/1 101/303.53/1
98/0.0/1
35/0.0610/2 42/41791/2 44/86.57/2 108/0.0948/1 110/262.58/1
99/0.0/1
40/0.3349/2 37/107503/2 35/98.74/2 90/0.4955/2
90/28942/2
94/99.71/2
41/0.2666/2 40/49870/2 43/92.79/2 85/0.2606/2
88/27756/2
87/98.82/2
36/0.1451/2 38/48533/2 41/92.73/2 94/0.0436/2
86/23005/2
91/94.72/2
35/0.1391/2 39/43707/2 36/87.97/2 89/0.0253/2
89/12090/2
92/93.69/2
39/0.1391/2 42/41791/2 44/86.57/2 107/0.0246/1
92/9620/2
93/93.69/2
38/0.4044/1 37/107503/2 35/98.74/2 90/0.5787/2
90/28942/2
94/99.71/2
40/0.1468/2 40/49870/2 43/92.79/2 85/0.3044/2
88/27756/2
87/98.82/2
41/0.1169/2 38/48533/2 41/92.73/2 94/0.0509/2
86/23005/2
91/94.72/2
36/0.0636/2 39/43707/2 36/87.97/2 89/0.0296/2
89/12090/2
92/93.69/2
35/0.0610/2 42/41791/2 44/86.57/2 88/0.0088/2
92/9620/2
93/93.69/2
38/0.4044/1 37/107503/2 35/98.74/2 90/0.4955/2
90/28942/2
94/99.71/2
40/0.1468/2 40/49870/2 43/92.79/2 85/0.2606/2
88/27756/2
87/98.82/2
41/0.1169/2 38/48533/2 41/92.73/2 94/0.0436/2
86/23005/2
91/94.72/2
60
Agente 10
36/0.0636/2 39/43707/2 36/87.97/2 89/0.0253/2
89/12090/2
92/93.69/2
35/0.0610/2 42/41791/2 44/86.57/2 107/0.0246/1
92/9620/2
93/93.69/2
38/0.7201/1 45/1100.9/1
37/8.32/1
90/0.4955/2
90/28942/2
94/99.71/2
36/0.0888/1 38/780.6/1
38/8.11/1
85/0.2606/2
88/27756/2
87/98.82/2
45/0.0723/1 37/395.36/1
45/8.11/1
94/0.0436/2
86/23005/2
91/94.72/2
39/0.0278/1 41/331.76/1
35/8.09/1
89/0.0253/2
89/12090/2
92/93.69/2
37/0.0265/1 44/227.61/1
42/8.02/1 107/0.0246/1
92/9620/2
93/93.69/2
61
2. Experimento 2
Agente 1
Agente 1
Tabla 18. Primera corrida
Per/Prob/Ri
C1
Per/Pop/Ri
Per/Rat/Ri
C3
Per/Pop/Ri
Per/Prob/Ri
C4
Per/Pop/Ri
Per/Rat/Ri
Per/Rat/Ri
33/0.7957/1
28/426.6/1
23/0.0/1
62/0.4050/2 22/113010/2 21/85.24/2 78/0.2617/2 75/94782/2
84/93.8/2
55/0.2327/1
58/574.5/1
50/8.48/1
32/0.0846/1
24/346.9/1
24/0.0/1
101/0.0981/2 23/113010/2 64/85.24/2 80/0.1969/2 81/90383/2
78/93.6/2
50/0.1910/1
55/523.9/1
55/8.44/1
25/0.0236/1
34/282.9/1
25/0.0/1
69/0.0628/2 70/113010/2 20/85.05/2 82/0.1183/2 76/88915/2
79/93.6/2
49/0.1820/1
50/255.9/1
53/8.4/1
27/0.0196/1
27/226.3/1
26/0.0/1
72/0.0469/2 71/104910/2 63/85.05/2 79/0.1051/2 74/68795/2
80/92.1/2
56/0.0778/1
52/192.6/1
58/8.38/1
23/0.0164/1
29/226.3/1
27/0.0/1
95/0.0436/2
61/98194/2 69/85.05/2 75/0.0836/2 83/34283/2
82/90.1/2
57/0.0543/1
54/192.3/1
52/8.04/1
Per/Prob/Ri
C5
Per/Pop/Ri
Per/Prob/Ri
C6
Per/Pop/Ri
Per/Prob/Ri
C8
Per/Pop/Ri
Per/Rat/Ri
Per/Rat/Ri
Per/Prob/Ri
C2
Per/Pop/Ri
Per/Rat/Ri Per/Prob/Ri
Per/Rat/Ri Per/Prob/Ri
C7
Per/Pop/Ri
Per/Rat/Ri
104/0.4371/1 109/3583.8/1 109/8.71/1
36/0.5357/2 37/107503/2 35/98.74/2 101/0.5006/2 100/48245/2 95/68.34/2
101/0.1608/1
100/683/1
81/8.31/1
35/0.1618/1 40/49870/2 43/92.79/2 95/0.2783/2
110/0.0865/1
81/677.9/1
101/8.2/1
102/0.0661/1 101/303.5/1
98/0.0/1
41/0.0359/2 39/43707/2 36/87.97/2 97/0.0465/2 101/15675/2 99/18.7/2
100/0.0409/1 110/262.5/1
99/0.0/1
39/0.0290/1 42/41791/2 44/86.57/2 99/0.0357/2
No encontrado
98/45684/2 101/57.4/2
37/0.0444/1 38/48533/2 41/92.73/2 100/0.1102/2 96/21349/2 98/26.35/2
95/8164/2
97/8.12/2
Agente 2
Agente 1
Tabla 19. Segunda corrida
Per/Prob/Ri
C1
Per/Pop/Ri Per/Rat/Ri
Per/Prob/Ri
C3
Per/Pop/Ri
Per/Rat/Ri
Per/Prob/Ri
C4
Per/Pop/Ri
Per/Rat/Ri
33/0.8029/1
28/426.6/1
23/0.0/1
63/0.5230/2 22/113010/2 21/85.24/2 82/0.6733/2 75/94782/2
84/93.8/2
55/0.4965/1
58/574.5/1
50/8.48/1
32/0.0428/1
24/346.9/1
24/0.0/1
62/0.1706/2 23/113010/2 64/85.24/2 75/0.1037/2 81/90383/2
78/93.6/2
46/0.0931/1
55/523.9/1
55/8.44/1
23/0.0284/1
34/282.9/1
25/0.0/1
100/0.0524/2 70/113010/2 20/85.05/2 78/0.0911/2 76/88915/2
79/93.6/2
50/0.0859/1
50/255.9/1
53/8.4/1
27/0.0253/1
27/226.3/1
26/0.0/1
23/0.0444/2 71/104910/2 63/85.05/2 80/0.0495/2 74/68795/2
80/92.1/2
49/0.0773/1
52/192.6/1
58/8.38/1
25/0.0202/1
29/226.3/1
27/0.0/1
69/0.0230/2
61/98194/2 69/85.05/2 81/0.0309/2 83/34283/2
82/90.1/2
52/0.0719/1
54/192.3/1
52/8.04/1
34/0.6455/2 34/65624/2 33/88.23/2 63/0.5230/2 22/113010/2 21/85.24/2 82/0.6733/2 75/94782/2
84/93.8/2
55/0.4965/1
58/574.5/1
50/8.48/1
33/0.0734/2 32/34605/2 30/86.94/2 62/0.1706/2 23/113010/2 64/85.24/2 75/0.1037/2 81/90383/2
78/93.6/2
46/0.0931/1
55/523.9/1
55/8.44/1
32/0.0732/2 44/20469/2 31/86.94/2 100/0.0524/2 70/113010/2 20/85.05/2 78/0.0911/2 76/88915/2
79/93.6/2
50/0.0859/1
50/255.9/1
53/8.4/1
44/0.0695/2 30/19899/2 44/86.57/2 23/0.0444/2 71/104910/2 63/85.05/2 80/0.0495/2 74/68795/2
80/92.1/2
49/0.0773/1
52/192.6/1
58/8.38/1
25/0.0476/2 31/19899/2 32/77.29/2 69/0.0230/2
82/90.1/2
52/0.0719/1
54/192.3/1
52/8.04/1
Per/Prob/Ri
C8
Per/Pop/Ri
Per/Rat/Ri
Per/Prob/Ri
C5
Per/Pop/Ri Per/Rat/Ri
Per/Prob/Ri
C2
Per/Pop/Ri
61/98194/2 69/85.05/2 81/0.0309/2 83/34283/2
C6
Per/Pop/Ri
Agente 2
Agente 1
111/0.2860/1 90/28942/2 94/99.7/2
104/0.1135/1 88/27756/2 87/98.8/2
90/0.0863/2 86/23005/2 91/94.7/2
Per/Rat/Ri Per/Prob/Ri
Per/Rat/Ri Per/Prob/Ri
C7
Per/Pop/Ri
Per/Rat/Ri
36/0.5095/2 37/107503/2 35/98.74/2 100/0.2386/2 100/48245/2 95/68.34/2
No encontrado
35/0.1078/1 40/49870/2 43/92.79/2 95/0.2028/2
98/45684/2 101/57.4/2
37/0.0632/1 38/48533/2 41/92.73/2 98/0.1549/2
96/21349/2 98/26.35/2
94/0.0648/2 89/12090/2 92/93.6/2
41/0.0461/1 39/43707/2 36/87.97/2 97/0.1498/2 101/15675/2 99/18.7/2
110/0.0492/1 92/9620/2
40/0.0341/2 42/41791/2 44/86.57/2 101/0.1213/2
93/93.6/2
95/8164/2
97/8.12/2
111/0.2860/1 90/28942/2 94/99.7/2
36/0.5095/2 37/107503/2 35/98.74/2 100/0.2386/2 100/48245/2 95/68.34/2
104/0.1135/1 88/27756/2 87/98.8/2
35/0.1078/1 40/49870/2 43/92.79/2 95/0.2028/2
98/45684/2 101/57.4/2
37/0.0632/1 38/48533/2 41/92.73/2 98/0.1549/2
96/21349/2 98/26.35/2
90/0.0863/2 86/23005/2 91/94.7/2
No encontrado
94/0.0648/2 89/12090/2 92/93.6/2
41/0.0461/1 39/43707/2 36/87.97/2 97/0.1498/2 101/15675/2 99/18.7/2
110/0.0492/1 92/9620/2
40/0.0341/2 42/41791/2 44/86.57/2 101/0.1213/2
93/93.6/2
95/8164/2
97/8.12/2
Tabla 20. Tercera corrida
Agente 4
Agente 3
Agente 2
Agente 1
C4
C1
C2
Per/Prob/Ri Per/Pop/Ri Per/Rat/Ri
Per/Prob/Ri
Per/Pop/Ri
Per/Rat/Ri Per/Prob/Ri Per/Pop/Ri Per/Rat/Ri Per/Prob/Ri Per/Pop/Ri Per/Rat/Ri
34/0.1338/2 34/65624/2 33/88.23/2 73/0.5577/1
18/436.7/1
59/8.41/1 78/0.2096/2 75/94782/2 78/93.63/2 49//0.5298/1 58/574.5/1
50/8.48/1
27/0.1156/1 32/34605/2 30/86.94/2 17/0.0687/1
69/436.7/1
14/0.0/1
88/0.1505/1 81/90383/2 79/93.63/2 57/ 0.2057/1 55/523.9/1
55/8.44/1
29/0.1070/1 44/20469/2 31/86.94/2 14/0.0637/1
75/436.7/1
18/0.0/1
82/0.1057/2 74/68795/2 74/54.85/2 47/ 0.0560/1 50/255.9/1
53/8.4/1
28/0.0788/2 30/19899/2 44/86.57/2 62/0.0265/1
59/231.6/1
60/0.0/1
87/0.1027/1
78/9701/2
81/40.68/2 46/ 0.0436/1 52/192.6/1
58/8.38/1
44/0.0768/2 31/19899/2 32/77.29/2 70/0.0220/1
71/175.9/1
61/0.0/1
89/0.0705/1
79/9701/2
75/37.79/2 56/ 0.0262/1 54/192.3/1
52/8.04/1
27/0.2136/1 28/426.6/1
23/0.0/1
73/0.5577/1
18/436.7/1
59/8.41/1 78/0.2096/2 75/94782/2 78/93.63/2 49/0.4333/1 48/92694/2 46/99.2/2
29/0.1978/1 24/346.9/1
24/0.0/1
17/0.0687/1
69/436.7/1
14/0.0/1
88/0.1505/1 81/90383/2 79/93.63/2 57/0.1682/1 49/92694/2 53/95.9/2
26/0.1163/1 34/282.9/1
25/0.0/1
14/0.0637/1
75/436.7/1
18/0.0/1
82/0.1057/2 74/68795/2 74/54.85/2 47/0.0457/1 54/49197/2 47/95.8/2
34/0.1065/1 27/226.3/1
26/0.0/1
62/0.0265/1
59/231.6/1
60/0.0/1
87/0.1027/1
78/9701/2
81/40.68/2 46/0.0357/1 45/38169/2 52/93.3/2
30/0.1043/1 29/226.3/1
27/0.0/1
70/0.0220/1
71/175.9/1
61/0.0/1
89/0.0705/1
79/9701/2
75/37.79/2 53/0.0251/2 51/28828/2 11/91.5/2
27/0.2136/1 28/426.6/1
23/0.0/1
73/0.5577/1
18/436.7/1
59/8.41/1 78/0.2096/2 75/94782/2 78/93.63/2 49//0.5298/1 58/574.5/1
50/8.48/1
29/0.1978/1 24/346.9/1
24/0.0/1
17/0.0687/1
69/436.7/1
14/0.0/1
88/0.1505/1 81/90383/2 79/93.63/2 57/ 0.2057/1 55/523.9/1
55/8.44/1
26/0.1163/1 34/282.9/1
25/0.0/1
14/0.0637/1
75/436.7/1
18/0.0/1
82/0.1057/2 74/68795/2 74/54.85/2 47/ 0.0560/1 50/255.9/1
53/8.4/1
34/0.1065/1 27/226.3/1
26/0.0/1
62/0.0265/1
59/231.6/1
60/0.0/1
87/0.1027/1
78/9701/2
81/40.68/2 46/ 0.0436/1 52/192.6/1
58/8.38/1
30/0.1043/1 29/226.3/1
27/0.0/1
70/0.0220/1
71/175.9/1
61/0.0/1
89/0.0705/1
79/9701/2
75/37.79/2 56/ 0.0262/1 54/192.3/1
52/8.04/1
27/0.2136/1 28/426.6/1
23/0.0/1
72/0.2431/2 22/113010/2 21/85.24/2 78/0.4637/2 75/94782/2
84/93.8/2 49//0.5298/1 58/574.5/1
50/8.48/1
29/0.1978/1 24/346.9/1
24/0.0/1
3/0.2213/1
23/113010/2 64/85.24/2 82/0.2338/2 81/90383/2
78/93.6/2 57/ 0.2057/1 55/523.9/1
55/8.44/1
26/0.1163/1 34/282.9/1
25/0.0/1
70/0.1392/2 70/113010/2 20/85.05/2 80/0.0551/2 76/88915/2
79/93.6/2 47/ 0.0560/1 50/255.9/1
53/8.4/1
34/0.1065/1 27/226.3/1
26/0.0/1
17/0.0272/1 71/104910/2 63/85.05/2 74/0.0544/2 74/68795/2
80/92.1/2 46/ 0.0436/1 52/192.6/1
58/8.38/1
30/0.1043/1 29/226.3/1
27/0.0/1
14/0.0252/1
61/98194/2 69/85.05/2 83/0.0525/2 83/34283/2
82/90.1/2 56/ 0.0262/1 54/192.3/1
52/8.04/1
18/436.7/1
93/8.34/1 49//0.5298/1 58/574.5/1
50/8.48/1
34/0.2916/2 34/65624/2 33/88.23/2 73/0.5577/1
C3
59/8.41/1 88/0.2748/1 93/750.6/1
Agente 5
Agente 6
Agente 7
Agente 8
Agente 9
28/0.1718/2 32/34605/2 30/86.94/2 17/0.0687/1
69/436.7/1
14/0.0/1
87/0.1874/1 92/555.4/1
92/8.22/1 57/ 0.2057/1 55/523.9/1
55/8.44/1
44/0.1675/2 44/20469/2 31/86.94/2 14/0.0637/1
75/436.7/1
18/0.0/1
89/0.1288/1 89/313.06/1 85/8.12/1 47/ 0.0560/1 50/255.9/1
53/8.4/1
30/0.1554/2 30/19899/2 44/86.57/2 62/0.0265/1
59/231.6/1
60/0.0/1
95/0.0748/1 97/240.38/1 95/7.98/1 46/ 0.0436/1 52/192.6/1
58/8.38/1
32/0.0944/2 31/19899/2 32/77.29/2 70/0.0220/1
71/175.9/1
61/0.0/1
84/0.0548/1 12/148.19/1 89/7.66/1 56/ 0.0262/1 54/192.3/1
52/8.04/1
34/0.2916/2 34/65624/2 33/88.23/2 72/0.4031/2 22/113010/2 21/85.24/2 78/0.2096/2 75/94782/2 78/93.63/2 49//0.5298/1 58/574.5/1
50/8.48/1
28/0.1718/2 32/34605/2 30/86.94/2 70/0.2308/2 23/113010/2 64/85.24/2 88/0.1505/1 81/90383/2 79/93.63/2 57/ 0.2057/1 55/523.9/1
55/8.44/1
44/0.1675/2 44/20469/2 31/86.94/2 61/0.0361/2 70/113010/2 20/85.05/2 82/0.1057/2 74/68795/2 74/54.85/2 47/ 0.0560/1 50/255.9/1
53/8.4/1
30/0.1554/2 30/19899/2 44/86.57/2 101/0.0328/2 71/104910/2 63/85.05/2 87/0.1027/1
78/9701/2
81/40.68/2 46/ 0.0436/1 52/192.6/1
58/8.38/1
32/0.0944/2 31/19899/2 32/77.29/2 59/0.0326/2
61/98194/2 69/85.05/2 89/0.0705/1
79/9701/2
75/37.79/2 56/ 0.0262/1 54/192.3/1
52/8.04/1
27/0.2136/1 28/426.6/1
23/0.0/1
72/0.4031/2
22/113010/2 21/85.24/2 78/0.2096/2 75/94782/2 78/93.63/2 49/0.4333/1 48/92694/2 46/99.2/2
29/0.1978/1 24/346.9/1
24/0.0/1
70/0.2308/2
23/113010/2 64/85.24/2 88/0.1505/1 81/90383/2 79/93.63/2 57/0.1682/1 49/92694/2 53/95.9/2
26/0.1163/1 34/282.9/1
25/0.0/1
61/0.0361/2 70/113010/2 20/85.05/2 82/0.1057/2 74/68795/2 74/54.85/2 47/0.0457/1 54/49197/2 47/95.8/2
34/0.1065/1 27/226.3/1
26/0.0/1
101/0.0328/2 71/104910/2 63/85.05/2 87/0.1027/1
78/9701/2
81/40.68/2 46/0.0357/1 45/38169/2 52/93.3/2
30/0.1043/1 29/226.3/1
27/0.0/1
59/0.0326/2
61/98194/2 69/85.05/2 89/0.0705/1
79/9701/2
75/37.79/2 53/0.0251/2 51/28828/2 11/91.5/2
27/0.2136/1 28/426.6/1
23/0.0/1
72/0.4031/2
22/113010/2 21/85.24/2 78/0.2096/2 75/94782/2 78/93.63/2 49/0.4333/1 48/92694/2 46/99.2/2
29/0.1978/1 24/346.9/1
24/0.0/1
70/0.2308/2
23/113010/2 64/85.24/2 88/0.1505/1 81/90383/2 79/93.63/2 57/0.1682/1 49/92694/2 53/95.9/2
26/0.1163/1 34/282.9/1
25/0.0/1
61/0.0361/2 70/113010/2 20/85.05/2 82/0.1057/2 74/68795/2 74/54.85/2 47/0.0457/1 54/49197/2 47/95.8/2
34/0.1065/1 27/226.3/1
26/0.0/1
101/0.0328/2 71/104910/2 63/85.05/2 87/0.1027/1
78/9701/2
81/40.68/2 46/0.0357/1 45/38169/2 52/93.3/2
30/0.1043/1 29/226.3/1
27/0.0/1
59/0.0326/2
79/9701/2
75/37.79/2 53/0.0251/2 51/28828/2 11/91.5/2
34/0.2916/2 34/65624/2 33/88.23/2 72/0.4031/2
22/113010/2 21/85.24/2 88/0.2748/1 93/750.6/1
93/8.34/1 49/0.4333/1 48/92694/2 46/99.2/2
28/0.1718/2 32/34605/2 30/86.94/2 70/0.2308/2
23/113010/2 64/85.24/2 87/0.1874/1 92/555.4/1
92/8.22/1 57/0.1682/1 49/92694/2 53/95.9/2
61/98194/2 69/85.05/2 89/0.0705/1
44/0.1675/2 44/20469/2 31/86.94/2 61/0.0361/2 70/113010/2 20/85.05/2 89/0.1288/1 89/313.06/1 85/8.12/1 47/0.0457/1 54/49197/2 47/95.8/2
30/0.1554/2 30/19899/2 44/86.57/2 101/0.0328/2 71/104910/2 63/85.05/2 95/0.0748/1 97/240.38/1 95/7.98/1 46/0.0357/1 45/38169/2 52/93.3/2
32/0.0944/2 31/19899/2 32/77.29/2 59/0.0326/2
61/98194/2 69/85.05/2 84/0.0548/1 12/148.19/1 89/7.66/1 53/0.0251/2 51/28828/2 11/91.5/2
Agente 10
27/0.2136/1 28/426.6/1
23/0.0/1
72/0.4031/2
22/113010/2 21/85.24/2 88/0.2748/1 93/750.6/1
93/8.34/1
53/0.1378/2 48/92694/2 46/99.2/2
29/0.1978/1 24/346.9/1
24/0.0/1
70/0.2308/2
23/113010/2 64/85.24/2 87/0.1874/1 92/555.4/1
92/8.22/1
48/0.1230/2 49/92694/2 53/95.9/2
26/0.1163/1 34/282.9/1
25/0.0/1
61/0.0361/2 70/113010/2 20/85.05/2 89/0.1288/1 89/313.06/1 85/8.12/1
46/0.0991/2 54/49197/2 47/95.8/2
34/0.1065/1 27/226.3/1
26/0.0/1
101/0.0328/2 71/104910/2 63/85.05/2 95/0.0748/1 97/240.38/1 95/7.98/1
50/0.0939/2 45/38169/2 52/93.3/2
30/0.1043/1 29/226.3/1
27/0.0/1
59/0.0326/2
45/0.0922/2 51/28828/2 11/91.5/2
61/98194/2 69/85.05/2 84/0.0548/1 12/148.19/1 89/7.66/1
Tabla 21. Continuación Tercera corrida
Agente 3
Agente 2
Agente 1
C5
C6
C7
C8
Per/Prob/Ri
Per/Pop/Ri
Per/Rat/Ri Per/Prob/Ri Per/Pop/Ri Per/Rat/Ri Per/Prob/Ri
104/0.5060/1
90/28942/2
94/99.7/2
38/0.7338/1 37/107503/2 35/98.74/2 101/0.3396/2 100/48245/2 95/68.34/2
90/ 0.1478/2
88/27756/2
87/98.8/2
36/0.0548/1 40/49870/2 43/92.79/2 100/0.1882/2 98/45684/2 101/57.4/2
102/0.0580/1
86/23005/2
91/94.7/2
103/0.0358/1
89/12090/2
92/93.6/2
37/0.0292/1 39/43707/2 36/87.97/2 97/ 0.1067/2 101/15675/2 99/18.7/2
100/0.0250/1
92/9620/2
93/93.6/2
41/0.0288/1 42/41791/2 44/86.57/2 99/ 0.1035/2
104/0.5060/1
90/28942/2
94/99.7/2
38/0.7338/1 37/107503/2 35/98.74/2 101/0.3396/2 100/48245/2 95/68.34/2
90/ 0.1478/2
88/27756/2
87/98.8/2
36/0.0548/1 40/49870/2 43/92.79/2 100/0.1882/2 98/45684/2 101/57.4/2
102/0.0580/1
86/23005/2
91/94.7/2
103/0.0358/1
89/12090/2
92/93.6/2
37/0.0292/1 39/43707/2 36/87.97/2 97/ 0.1067/2 101/15675/2 99/18.7/2
100/0.0250/1
92/9620/2
93/93.6/2
41/0.0288/1 42/41791/2 44/86.57/2 99/ 0.1035/2
104/0.5060/1
90/28942/2
94/99.7/2
38/0.8251/1 45/1100.9/1
37/8.32/1 101/0.3396/2 100/48245/2 95/68.34/2
90/ 0.1478/2
88/27756/2
87/98.8/2
36/0.0617/1
38/780.6/1
38/8.11/1 100/0.1882/2 98/45684/2 101/57.4/2
102/0.0580/1
86/23005/2
91/94.7/2
37/0.0329/1
37/395.3/1
45/8.11/1 98/ 0.1439/2
103/0.0358/1
89/12090/2
92/93.6/2
41/0.0324/1
41/331.7/1
35/8.09/1 97/ 0.1067/2 101/15675/2 99/18.7/2
No encontrado
No encontrado
No encontrado
Per/Pop/Ri
Per/Rat/Ri
Per/Prob/Ri
38/0.0365/2 38/48533/2 41/92.73/2 98/ 0.1439/2
38/0.0365/2 38/48533/2 41/92.73/2 98/ 0.1439/2
Per/Pop/Ri
Per/Rat/Ri
96/21349/2 98/26.35/2
95/8164/2
97/8.12/2
96/21349/2 98/26.35/2
95/8164/2
97/8.12/2
96/21349/2 98/26.35/2
Agente 8
Agente 7
Agente 6
Agente 5
Agente 4
100/0.0250/1
92/9620/2
93/93.6/2
45/0.0116/1
44/227.6/1
42/8.02/1 99/ 0.1035/2
95/8164/2
97/8.12/2
104/0.6677/1 109/3583.8/1 109/8.71/1
38/0.7338/1 37/107503/2 35/98.74/2 101/0.3396/2 100/48245/2 95/68.34/2
102/0.0766/1
100/683/1
81/8.31/1
36/0.0548/1 40/49870/2 43/92.79/2 100/0.1882/2 98/45684/2 101/57.4/2
103/0.0473/1
81/677.9/1
101/8.2/1
38/0.0365/2 38/48533/2 41/92.73/2 98/ 0.1439/2
100/0.0330/1 101/303.5/1
98/0.0/1
107/0.0299/1 110/262.5/1
99/0.0/1
41/0.0288/1 42/41791/2 44/86.57/2 99/ 0.1035/2
90/0.6104/2
90/28942/2
94/99.7/2
38/0.7338/1 37/107503/2 35/98.74/2
87/0.0580/2
88/27756/2
87/98.8/2
36/0.0548/1 40/49870/2 43/92.79/2
93/0.0550/2
86/23005/2
91/94.7/2
85/0.0506/2
89/12090/2
92/93.6/2
37/0.0292/1 39/43707/2 36/87.97/2
88/0.0465/2
92/9620/2
93/93.6/2
41/0.0288/1 42/41791/2 44/86.57/2
No encontrado
No encontrado
96/21349/2 98/26.35/2
37/0.0292/1 39/43707/2 36/87.97/2 97/ 0.1067/2 101/15675/2 99/18.7/2
38/0.0365/2 38/48533/2 41/92.73/2
95/8164/2
97/8.12/2
No encontrado
104/0.6677/1 109/3583.8/1 109/8.71/1
38/0.8251/1 45/1100.9/1
37/8.32/1
102/0.0766/1
100/683/1
81/8.31/1
36/0.0617/1
38/780.6/1
38/8.11/1
103/0.0473/1
81/677.9/1
101/8.2/1
37/0.0329/1
37/395.3/1
45/8.11/1
100/0.0330/1 101/303.5/1
98/0.0/1
41/0.0324/1
41/331.7/1
35/8.09/1
107/0.0299/1 110/262.5/1
99/0.0/1
45/0.0116/1
44/227.6/1
42/8.02/1
104/0.5060/1
90/28942/2
94/99.7/2
38/0.7338/1 37/107503/2 35/98.74/2
90/ 0.1478/2
88/27756/2
87/98.8/2
36/0.0548/1 40/49870/2 43/92.79/2
102/0.0580/1
86/23005/2
91/94.7/2
103/0.0358/1
89/12090/2
92/93.6/2
37/0.0292/1 39/43707/2 36/87.97/2
100/0.0250/1
92/9620/2
93/93.6/2
41/0.0288/1 42/41791/2 44/86.57/2
104/0.5060/1
90/28942/2
94/99.7/2
38/0.3304/2 37/107503/2 35/98.74/2 101/0.3396/2 100/48245/2 95/68.34/2
90/ 0.1478/2
88/27756/2
87/98.8/2
40/0.1251/2 40/49870/2 43/92.79/2 100/0.1882/2 98/45684/2 101/57.4/2
102/0.0580/1
86/23005/2
91/94.7/2
41/0.1084/2 38/48533/2 41/92.73/2 98/ 0.1439/2
No encontrado
No encontrado
38/0.0365/2 38/48533/2 41/92.73/2
No encontrado
No encontrado
96/21349/2 98/26.35/2
Agente 9
Agente 10
103/0.0358/1
89/12090/2
92/93.6/2
44/0.1012/2 39/43707/2 36/87.97/2 97/ 0.1067/2 101/15675/2 99/18.7/2
100/0.0250/1
92/9620/2
93/93.6/2
104/0.5060/1
90/28942/2
94/99.7/2
38/0.3304/2 37/107503/2 35/98.74/2 101/0.3396/2 100/48245/2 95/68.34/2
90/ 0.1478/2
88/27756/2
87/98.8/2
40/0.1251/2 40/49870/2 43/92.79/2 100/0.1882/2 98/45684/2 101/57.4/2
102/0.0580/1
86/23005/2
91/94.7/2
103/0.0358/1
89/12090/2
92/93.6/2
44/0.1012/2 39/43707/2 36/87.97/2 97/ 0.1067/2 101/15675/2 99/18.7/2
100/0.0250/1
92/9620/2
93/93.6/2
43/0.0716/2 42/41791/2 44/86.57/2 99/ 0.1035/2
104/0.5060/1
90/28942/2
94/99.7/2
38/0.7338/1 37/107503/2 35/98.74/2 101/0.3396/2 100/48245/2 95/68.34/2
90/ 0.1478/2
88/27756/2
87/98.8/2
36/0.0548/1 40/49870/2 43/92.79/2 100/0.1882/2 98/45684/2 101/57.4/2
102/0.0580/1
86/23005/2
91/94.7/2
103/0.0358/1
89/12090/2
92/93.6/2
37/0.0292/1 39/43707/2 36/87.97/2 97/ 0.1067/2 101/15675/2 99/18.7/2
100/0.0250/1
92/9620/2
93/93.6/2
41/0.0288/1 42/41791/2 44/86.57/2 99/ 0.1035/2
No encontrado
No encontrado
No encontrado
43/0.0716/2 42/41791/2 44/86.57/2 99/ 0.1035/2
41/0.1084/2 38/48533/2 41/92.73/2 98/ 0.1439/2
38/0.0365/2 38/48533/2 41/92.73/2 98/ 0.1439/2
95/8164/2
97/8.12/2
96/21349/2 98/26.35/2
95/8164/2
97/8.12/2
96/21349/2 98/26.35/2
95/8164/2
97/8.12/2