REUSO DE COMPONENTES SOFTWARE MEDIANTE EL CALCULO

DE SIMILITUD1

RESUMEN

En este trabajo de investigación se presenta un algoritmo de agrupamiento en

conglomerados para organizar un repositorio de componentes mediante el calculo de la
similitud entre dos componentes software.

Un visor es el término usado para referirse a un grupo de componentes que son lo

suficientemente similares entre sí con respecto a su funcionalidad, y, por tanto, caen
dentro del mismo “campo de visión”.

El algoritmo propuesto produce visores rápidamente y con bajo costo computacional.

MATERIALES Y METODOS

En este trabajo de investigación, se asume que en el proceso de desarrollo de las

aplicaciones se utiliza el paradigma de orientación a objetos, por tanto, los componentes
software reutilizables serán subproductos del ciclo de vida de aplicaciones orientadas a
objeto. Aunque algunos autores limitan la definición de componente reutilizable solo a
aquellos componentes software que han sido desarrollados expresamente para su
reutilización, en este trabajo de investigación trabajaremos con otra definición menos
restrictiva:

Un componente reutilizable es cualquier subproducto del proceso de desarrollo de

software: objetos software ejecutables, especificaciones, documentación, diseños,
pruebas, y, en general, cualquier información o conocimiento generado durante la vida
del proyecto; perteneciente a cualquier fase del ciclo de vida: análisis, diseño,
implementación, mantenimiento. Los componentes reutilizables pueden provenir de
desarrollos anteriores, ser desarrollados ex-profeso para su reutilización, comprados a
organizaciones comerciales externas, etc.

A efectos de representar los componentes software reutilizables, se define el concepto

de descripción funcional, abreviado por DF en el resto de este trabajo:

Una descripción funcional es una combinación de términos que describen el comportamiento

de un componente software.
1.

Las DF poseen una semántica informal, permitiendo su independencia del componente

real, su estructura, lenguaje, esquema, etc. Además, liberan al usuario de la necesidad de

1
Msc. van Soto RodriguezProfesor Principal del Dpto. de Estadística e Informática de la UNALM
conocer el esquema de datos del repositorio, o su organización interna.

Una DF puede ser vista desde dos perspectivas distintas:

1. Como un conjunto de características, o propiedades, asociadas estáticamente a un

componente; o
2. Como un conjunto de requisitos o especificaciones, es decir, una consulta asociada
dinámicamente a un usuario.

Por tanto, las DF son un mecanismo lingüístico, tanto de clasificación como de

recuperación. La combinación de términos a que se hace referencia en la definición de
DF se limita a pares de términos (propiedad) y un valor difuso, conformando las
características.

Una propiedad es un par ordenado de términos: <término1, término2>.

Una característica es una tripleta de la forma <propiedad,valor difuso>, es decir,
<término1, término2, valor difuso>

El valor difuso representa un “peso” o “importancia” relativa de la propiedad en la DF.

Puede entenderse como una valoración de que “tan bién”, esa propiedad, representa o
describe el comportamiento del componente expresado por la DF. El uso de este valor
difuso aporta un soporte importante a la imprecisión, por tanto indica, en cierta medida,
el grado de imprecisión que caracteriza a la DF, ayudando a los desarrolladores de
aplicaciones a recuperar componentes candidato para la reutilización, y al ingeniero de
software a clasificar los componentes reutilizables. Más aún, estos valores difusos
resultan muy adecuados para implementar un sistema de clasificación/recuperación
adaptativo, que mediante la observación del comportamiento del usuario (feedback)
ante los resultados obtenidos, pueda ir ajustando los valores difusos, a efectos de lograr
un incremento en el poder descriptivo de la DF y su exactitud representativa.

Elementos de una DF: la propiedad:

Una propiedad puede ser una combinación de los siguientes tipos:

1. <verbo, nombre> (verbo expresa acción o función, y nombre representa al objeto)

2. <nombre, adjetivo> (donde adjetivo representa alguna característica del objeto)
3. <nombre, nombre> (expresando relación entre dos objetos)
4. o cualquier otra combinación de dos términos

Las propiedades se usan, para calcular la similitud entre componentes, y pueden

obtenerse a partir de expertos (ingeniero de sistemas), o a partir de descripciones
textuales presentes en la documentación de los componentes, tales como:

1. listados de codigo fuente (para componentes ejecutables)

2. diversos manuales (funciones, procedimientos, esquemas, etc.)
3. bibliotecas de la organización
4. terminología de la metodología de desarrollo empleada, etc.

2
Por tanto, a las propiedades pueden asociarse diversas interpretaciones, según el caso y
el contexto de uso. Una propiedad puede describir la acción realizada sobre un objeto
(<verbo, nombre>), explicitando el comportamiento; o una característica pasiva del
componente (<nombre, adjetivo> o <nombre, nombre>). Denominaremos, a estos dos
tipos de propiedades, activas y pasivas respectivamente. Por lo general, las propiedades
activas se usarán para describir funcionalidades o servicios ofrecidos por el
componente, mientras que las pasivas describiran características no-funcionales.

Un ejemplo de propiedad activa es <ordenar, archivo>, donde ordenar expresa una

acción (verbo) y archivo denota al objeto sobre el cual se realiza la acción. Una
propiedad pasiva podría ser <acoplamiento, alto>, donde acoplamiento determina una
categoría o propiedad no-funcional, y el adjetivo alta expresa el valor de esa categoría.

3. Elementos de una DF: el valor difuso

Cada una de las propiedades en una DF puede ser “valorada” asignandole un valor
difuso que representa un índice de relevancia de la propiedad dentro de la DF. En una
DF, el valor difuso representa el poder descriptivo de una propiedad con respecto al
comportamiento general del componente representado por la DF. En una consulta, el
valor difuso representa que tan relevante es esa propiedad para el reutilizador.

El mecanismo de valores difusos no impone restricciones a su uso y, puede contribuir

eficazmente a incrementar el poder de la recuperación y la precisión de las consultas del
reutilizador, siempre y cuando su uso este basado en un marco lingüístico adecuado, y
un marco de entendimiento común entre clasificadores (ingenieros de software) y
reutilizadores (desarrolladores de aplicaciones).

En lo sucesivo, denominaremos importancia al valor difuso asignado a una propiedad,

entendiendo que es un término más adecuado para representar la función del valor
difuso en una característica.

Puesto que los valores asignados a la importancia pueden dificultar la correcta

interacción del usuario con el sistema de recuperación, se han reducido a un conjunto de
valores discretos, representados por los siguientes símbolos mnemónicos:

• MP Muy Poca Por debajo de un 10% de capacidad de

representación
• P Poca Entre un 10% y un 25% de representatividad
• M Media Alrededor de un 50% de capacidad de
representación
• A Alta En torno al 75% de representatividad
• MA Muy Alta 100% de representatividad

El último símbolo (MA) se asigna a aquellas características que permiten describir

totalmente la funcionalidad principal del componente. A efectos de cálculo numérico,
para hallar la similitud entre componentes, o entre consultas y componentes, se utiliza
una conversión de valores símbolo a números:

MP = 1/16 P = 1/8 M=¼ A=½ MA = 1

3
 CALCULO DE LA SIMILITUD ENTRE DOS COMPONENTES
SOFTWARE

Dados dos componentes software cualesquiera, el esquema de organización del

repositorio necesita calcular la similitud entre ellos. La similitud entre dos componentes
es un número indicativo de su cercanía conceptual (funcional), con el propósito de
poder intercambiarlos durante el proceso de desarrollo de software. Definimos similitud
como:

La similitud entre 2 DF es un valor que indica en que medida la primera DF pueda ser
sustituida por la segunda mientras se mantienen los requisitos funcionales de la
aplicación en desarrollo.

El método propuesto para el cálculo de similitud toma dos componentes expresados

como descripciones funcionales y devuelve un número entre 0 y 1 (valor normalizado),
el cual indica el grado de similitud entre ambos componentes. Cuanto más cercano sea
este número a 1 más similares entre sí serán los componentes, el caso especial de
similitud = 1 significaría que un componente puede reemplazar completamente al otro
(es funcionalmente idéntico). Nótese que lo anterior no significa, en modo alguno, que
los componentes sean idénticos, solo significa que ofrecen la misma funcionalidad.

Este mecanísmo de cálculo de similitud ha sido usado en diversos proyectos de

investigación, entre los que destacan: Ithaca Software Information Base [Fugini92], y F3
[Bubenk95]. Dados dos componentes C1 y C2, expresados mediante sus DF, se
construyen las siguientes matrices:

1. EQ (equivalencia): expresa el grado de compatibilidad entre los

términos usados por la i-ésima característica de la DF_C1 y la j-ésima
de la DF_C2. Es decir, se compara cada propiedad de la DF_C1 con
cada propiedad de la DF_C2, en caso de no existir sinónimos un valor
0 indica que las propiedades son distintas y un valor 1 que son
idénticas. Si hay sinónimos un 0 indicaría que las propiedades son
distintas y que tampoco existe ningún sinónimo, en cualquier otro
caso se asignaría el valor de similitud del sinónimo (que tan
representativo es del término cabeza de lista). EQ es una matriz C1 x
C2 (número de características en la DF_C1 x número de
características en la DF_C2). Esta matriz solo puede contener, como
máximo, un valor 1 por cada fila/columna. Si los dos componentes
son idénticos, EQ es la matriz Identidad.

2. IMP (importancia): expresa el grado de importancia entre la j-ésima

característica de la DF_C2 y la i-ésima de la DF_C1, o lo que viene a
ser lo mismo: que tan reemplazable sería la característica i-ésima (en
DF_C1) por la j-ésima (en DF_C2). La importancia se calcula como el
mínimo entre 1 y I1/I2, donde I1 es la <importancia> en la DF_C1 e I2
la <importancia> en la DF_C2. El grado de IMP es C2 x C1. Hay que
tener en cuenta que para cualquier entrada EQ[i,j] = 0
IMP[j,i] =

4
 0. Por tanto, solo cuando las propiedades son iguales o equivalentes
(sinónimos) se toma en cuenta su <importancia>.

3. IN (importancia normalizada): las importancias normalizadas de la

DF_C1. Cada entrada en IN es un valor entre 0 y 1, representando el
porcentaje de la <importancia> dentro de su DF. Como hay una
<importancia> por cada característica de la DF el grado de IN es C1 x
1.

4. SAT (satisfacción): combina EQ e IMP y se calcula como EQ x IMP,

por tanto será de grado C1 x C1. Representa la importancia relativa de
las importancias idénticas en las dos DF.

5. SIM (similitud) es el producto de SAT x IN, cada valor SIM[k]

representa un índice de satisfacción ponderado (según su importancia
normalizada) de la característica k en la DF1 con respecto a la DF2
(de nuevo, la medida en que la DF2 puede reemplazar a la DF1).

El valor final de la similitud se obtiene sumando todos los elementos de SIM, es un

valor normalizado (entre 0 y 1) que representa la cercanía de la DF1 a la DF2.

RESULTADOS

Caso practico :

Nº característica DF1 DF2

1 <tope-pila, M> <longitud-arreglo, M>
2 <sacar-pila, MA> <longitud-cola, P>
3 <tope-pila, MP>

Tabla 1 DF’s del componente requerido (1) y el almacenado (2)

De acuerdo a la tabla anterior tenemos que los tamaños de las matrices serán:

• EQ = [2x3] (DF1 x DF2)

• IMP = [3x2] (DF2 x DF1)
• IN = [2x1] (DF1 x 1)
• SAT = [2x2] (EQ x IMP
2x3 X 3x2)
• SIM = [2x1] (SAT x IN
2x2 X 2x1)

0 0 1
EQ =  
0 0 0

EQ[1,3] = 1 y el resto 0; por tanto, solo necesito calcular IMP [3,1], el resto será 0

5
IMP[3,1] = min (1, MP/M) = min (1, (1/16)/(1/4)) = min (1, ¼) = 0,25

 0 0
 
IMP =  0 0
 0,25 0 
 

Para el cálculo de IN solo se toma el componente DF1, en este caso tenemos 2

<importancias>, M y MA, o equivalentemente, 1 y ¼ , por tanto: 1 + ¼ = 5/4 , así pues:

IN[1] = M / (M + MA) = (1/4) / (5/4) = 1/5 = 0,2

IN[2] = MA / (M + MA) = 1 / (5/4) = 4/5 = 0,8

 0,2 
IN =  
 0,8 

SAT = EQ x IMP , por tanto SAT[1,1] =0,25 y el resto 0

 0 0
0 0 1    0,25 0 
SAT =   X  0 0  =  
 0 0 0   0,25 0   0 0 
 

Finalmente, SIM = SAT x IN, por tanto

 0,25 0  0,2   0,05 

SIM =    =  
 0 0  0,8   0 
El valor final de la similitud entre los dos componentes será Σ(SIM) = SIM[1] +
SIM[2], es decir, 0,05 + 0 = 0,05 < MP. Esto quiere decir que la similitud es muy baja
y que el componente DF2 no es un buen candidato para reemplazar a DF1.

AGRUPAMIENTO EN VISORES MEDIANTE SIMILITUD

Usaremos α para representar el valor de similitud entre dos componentes,

concretamente entre el componente que vamos a insertar en un visor y los componentes
referencia que constituyen los ejes de nuestro espacio multidimensional. Usaremos sim
como la función que devuelve el valor α. . Definimos un valor U (umbral) como radio
máximo de los visores, a efectos de determinar cuales componentes estan al alcance del
visor (caen dentro de su campo de visión). Se define una métrica de distancia, calculada
como: d = |1-α |.

El esquema

La idea básica consiste en ver al repositorio como un espacio k-dimensional, definido

por k características provenientes de los mismos componentes que se almacenaran en el
repositorio. Es decir, se trata de construir un espacio que se auto-genera a medida que
van llegando nuevos componentes para clasificar, por tanto, k no es un valor

6
preestablecido, aunque tiende a estabilizarse rápidamente a medida que se insertan
componentes en el repositorio.

Cuando llega el primer componente no existe aún espacio, por tanto, se extraen sus
características (tuplas que conforman su DF), y cada una de ellas da origen a una
dimensión del espacio. Asi, a medida que se intenta clasificar a nuevos componentes, se
van comparando las nuevas características con las ya representadas en el espacio,
añadiendose en el caso de que aún no esten representadas. Este proceso genera
dimensiones rapidamente y en gran cantidad, pero solo en la fase inicial, a medida que
el repositorio se va llenando cada vez son menos las características que no se encuentran
ya representadas en el espacio, llegando a una situación de estabilidad cuando el
repositorio tiene una carga representativa (media). Por ejemplo, si consideramos un
repositorio que almacena alrededor de 100.000 componentes, donde cada componente
se representa por una media de 3 características, y todos los componentes pertenecen a
un único dominio de aplicación; es razonable estimar que el número de dimensiones del
espacio ronde las 3.000, es decir, solo uno (1) de cada 100 componentes aporta una (de
sus 3) característica a la dimensionalidad del espacio.

Los componentes son introducidos en el repositorio de acuerdo con su similitud en el

espacio k-dimensional, y se forman los visores, que agrupan a componentes similares.
Los componentes cercanos en el espacio k-dimensional (de acuerdo a su similitud) son
colocados en el mismo visor, es decir, estaran dentro del campo de vision de un mismo
visor.

A cada visor se le asocia un centro. El centro es un vector k-dimensional que representa

la localización promedio de todos los componentes pertenecientes a ese visor dentro del
espacio k-dimensional, esto nos ofrece una funcionalidad promedio del conjunto de
componentes que pertenecen al visor, lo cual resulta del máximo interés para los
desarrolladores de futuros componentes reutilizables, ofreciendo guías sobre la
funcionalidad que debe ofrecer el nuevo componente.

Una labor de mantenimiento y actualización importante dentro del repositorio consistirá

en el reemplazo de un visor completo (grupos de componentes similares) por un solo
macrocomponente, que ofrezca la funcionalidad global suministrada por los antiguos
componentes.

Detalle del algoritmo:

La idea básica del esquema, y por tanto del algoritmo que lo implementa, es la de ver el
repositorio como un espacio en continuo crecimiento, definido por las características de
los propios componentes que se intenta clasificar.

Los componentes que llegan se “sitúan” en este espacio de acuerdo a su similitud con
las dimensiones del espacio (que actúan como ejes de coordenadas), y se agrupan en
visores (conjuntos de componentes con un valor de similitud mayor que un valor umbral
preestablecido). En otras palabras, los componentes “cercanos” en este espacio n-
dimensional son agrupados en el mismo visor. Cada visor esta asociado a su “centro”
(analogía de la esfera); el centro es un vector n-dimensional que representa la

7
“ubicación promedio” de todos los componentes del visor, es decir, la funcionalidad
promedio.

La ubicación de cualquier componente también es un vector n-dimensional, el cual

indica la posición relativa del componente con respecto a las n dimensiones del espacio.
Para elegir el visor en el que debe incluirse el nuevo componente a insertar se calculan
las distancias a todos los centros de los visores ya existentes, y se elige la menor (el
visor con centro más cercano), las distancias se calculan por diferencia (|1-sim|) ;
cuando alguna de estas distancias supera el valor umbral se detiene el cálculo para ese
visor y se marca como no-posible (es decir, ese visor no puede contener al componente).
Los visores que superan este cálculo (están por debajo del umbral) se agrupan en un
conjunto, del cual se elige, finalmente, el visor que incluirá al nuevo componente (será
aquel cuyo centro presente una mayor similitud con respecto al componente). Una vez
elegido el visor que contendrá al nuevo componente, su centro debe cambiar de
posición, a efectos de seguir representado la funcionalidad promedio.

Supongamos un valor umbral U (preestablecido) y las siguientes variables:

1. dim nº de dimensiones = nº de componentes referencia (*valor inicial = 0*)

2. numvis nº de visores (*valor inicial = 0*)
3. n nº de componentes en el repositorio (*valor inicial = 0*)
4. lcv lista de componentes asignados a un visor (*Id del componente*)
5. lv lista de visores (*lista de lcv*)

Proceso de inserción de componentes en el repositorio:

1. n = n + 1; se verifica si las características de Cn existen como componentes

referencia.
1.1. No, entonces (*se crean los componentes referencia respectivos*)
1.1.1. desde i = 1 hasta numcar hacer
1.1.1.1.dim = dim + 1; Rdim = cni
2. desde i = 1 hasta dim hacer:
2.1. se calcúla sim(Cn,Ri), según el procedimiento de cálculo de similitud

3. posición de Cn = (sim(Cn,R1), sim(Cn,R2),..., sim(Cn,Rdim))

4. desde i = 1 hasta numvis hacer:

4.1. se cálcula la distancia desde Cn hasta el centro del visor Vnumvis
(denotemos este centro por cvnumvis), si 1 − sim( Cn , cv numvis ) ≤ U (*la
primera parte de la inecuación representa la distancia entre Cn y el centro
del visor Vnumvis*) entonces se guarda en posibles[numvis] la distancia (*
1-sim*)(* en realidad, posibles es una lista, no una matríz, puesto que no
se sabe, a priori, el número de visores que habrá*), sino se guarda en
posibles[numvis] el valor nulo (0).

5. si lista de posibles no esta vacia, entonces:

5.1. posibles se ordena por orden ascendente, y se elige el visor cuyo centro
esta más cerca de Cn.

8
6. sino: (* creamos un nuevo visor*)
6.1. numvis = numvis +1
6.2. hacemos cvnumvis = Cn (* hacemos coincidir el centro del visor con el
componente*)
6.3. se crea una nueva lista lcv (*la número numvis*)

7. se añade el valor n en la lista lcv correspondiente (numvis) (*asignamos Cn al

visor Vnumvis*)

8. se verifica si Vnumvis puede ver a otros componentes, Si puede, entonces:

8.1. para cada componente C visto por Vnumvis hacer:
8.1.1. asignar C a Vnumvis (*es decir, actualizar lcv *)
8.1.2. mover (Vnumvis)
9. fin

RESULTADOS

Caso práctico:

Consideremos los 5 componentes que se muestran en la siguiente tabla:

Componente Características
C1 mete-elemento, A
saca-elemento, A
C2 tamaño-arreglo, MP
tamaño-cola, P
C3 tope-pila, M
saca-pila, MA
C4 mete-elemento, A
C5 tamaño-arreglo, P
tamaño-cola, M

Tabla 2 Componentes a insertar en el repositorio

Supongamos un valor umbral U = 0,25. (* es decir, no se aceptaran componentes con

una similitud menor al 25% *)

Comencemos por C1:

1. n = 1; se verifica si las características de C1 existen como componentes

referencia.
1.1. No, entonces (*se crean los componentes referencia respectivos*)
1.1.1. desde i = 1 hasta 2 hacer
1.1.1.1.dim = 1; R1 = C11 (*mete-elemento,A*)
1.1.1.2.dim = 2; R2 = C12 (*saca-elemento,A*)
2. desde i = 1 hasta 2 hacer:
2.1. sim(C1,R1) = 0,5 ; sim(C1,R2) = 0,5

9
3. posición de C1 = (0,5 ; 0.5)
4. desde i = 1 hasta 0 hacer: (*para C1 no se entra en este bucle*)
5. sino: (* creamos un nuevo visor*)
5.1. numvis = 1
5.2. hacemos cv1 = C1 (* hacemos coincidir el centro del visor con el
componente*)
5.3. se crea una nueva lista lcv (*la número 1*)
6. se añade el valor 1 en la lista lcv correspondiente (la 1)
7. se verifica si V1 puede ver a otros componentes, Si puede, entonces: (*V1 no ve
a ningún otro componente*).
8. fin

Componentes
referencia
mete-elemento, A
saca-elemento, A

Visores
1

Centro de Visor
C1

Para C2 tendremos:

1. n = 2; se verifica si las características de C2 existen como componentes

referencia.
1.1. No, entonces (*se crean los componentes referencia respectivos*)
1.1.1. desde i = 1 hasta 2 hacer
1.1.1.1.dim = 3; R3 = C21 (*tamaño-arreglo,MP*)
1.1.1.2.dim = 4; R4 = C22 (*tamaño-cola,P*)
2. desde i = 1 hasta 4 hacer:
2.1. sim(C2,R1) = 0 ; sim(C2,R2) = 0; sim(C2,R3) = 0,33; sim(C2,R4) = 0,67;
3. posición de C2 = (0 ; 0 ; 0,33 ; 0,67)
4. desde i = 1 hasta 1 hacer: (*para C2 se entra en este bucle 1 sola vez*)
4.1. se cálcula la distancia desde C2 hasta el centro del visor V1 (denotemos
este centro por cv1), si 1 − sim( C2 , cv1 ) ≤ U (* 1 - sim(C2 , C1) = 1 - 0 =
1 > U *)
5. sino: (* creamos un nuevo visor*)
5.1. numvis = 2
5.2. hacemos cv2 = C2 = (0 ; 0 ; 0,33 ; 0,67)
5.3. se crea una nueva lista lcv (*la número 2*)
6. se añade el valor 2 en la lista lcv correspondiente (2) (*asignamos C2 al visor
V2*)
7. se verifica si V2 puede ver a otros componentes, Si puede, entonces: (*V2 no ve
a ningún otro componente*).
8. fin

10
 Componentes
referencia
mete-elemento, A
saca-elemento, A
tamaño-arreglo, MP
tamaño-cola, P

Visores
1, 2

Centros de Visores
C1, C2

Para C3 tendremos:

1. n = 3; se verifica si las características de C3 existen como componentes

referencia.
1.1. No, entonces (*se crean los componentes referencia respectivos*)
1.1.1. desde i = 1 hasta 2 hacer
1.1.1.1.dim = 5; R5 = C31 (*tope-pila.M*)
1.1.1.2.dim = 6; R6 = C32 (*saca-pila,MA*)
2. desde i = 1 hasta 6 hacer:
2.1. sim(C3,R1) = 0; sim(C3,R2) = 0; sim(C3,R3) = 0; sim(C3,R4) = 0;
sim(C3,R5) = 0,2;
sim(C3,R6) = 0,8;
3. posición de C3 = (0 ; 0 ; 0; 0; 0,2; 0,8)
4. desde i = 1 hasta 2 hacer: (*para C3 se entra en este bucle 2 veces, porque
existen 2 visores*)
4.1. si 1 − sim( C3 , cv1 ) ≤ U (* 1 - sim(C3 , C1) = 1 - 0 = 1 > U *)
4.2. si 1 − sim( C3 , cv 2 ) ≤ U (* 1 - sim(C3 , C2) = 1 - 0 = 1 > U *)
5. sino: (* creamos un nuevo visor*)
5.1. numvis = 3
5.2. hacemos cv3 = C3 = (0 ; 0 ; 0; 0; 0,2; 0,8)
5.3. se crea una nueva lista lcv (*la número 3*)
6. se añade el valor 3 en la lista lcv correspondiente (3) (*asignamos C3 al visor
V3*)
7. se verifica si V3 puede ver a otros componentes, Si puede, entonces: (*V3 no ve
a ningún otro componente*).
8. fin

11
 Componentes
Referencia
mete-elemento, A
saca-elemento, A
tamaño-arreglo, MP
tamaño-cola, P
tope-pila, M
saca-pila, MA

Visores
1, 2, 3

Centros de Visores
C1, C2, C3

Para C4 tendremos:

1. n = 4; se verifica si las características de C4 existen como componentes

referencia.
1.1. Si existen, por tanto no se hace nada
2. desde i = 1 hasta 6 hacer:
2.1. sim(C4,R1) = 1; sim(C4,R2) = 0; sim(C4,R3) = 0; sim(C4,R4) = 0;
sim(C4,R5) = 0;
sim(C4,R6) = 0;
3. posición de C4 = (1 ; 0 ; 0; 0; 0; 0)
4. desde i = 1 hasta 3 hacer: (*para C4 se entra en este bucle 3 veces, porque
existen 3 visores*)
4.1. si 1 − sim( C4 , cv1 ) ≤ U (* 1 - sim(C4 , C1) = 1 - 1 = 0 < U *)
4.2. si 1 − sim( C4 , cv 2 ) ≤ U (* 1 - sim(C4 , C2) = 1 - 0 = 1 > U *)
4.3. si 1 − sim( C4 , cv 3 ) ≤ U (* 1 - sim(C4 , C3) = 1 - 0 = 1 > U *)
5. si lista de posibles no esta vacia, entonces:
5.1. posibles se ordena por orden ascendente, y se elige el visor cuyo centro
esta más cerca de C4. Elegimos el visor V1. Mover(V1)
6. se añade el valor 4 en la lista lcv correspondiente (1) (*asignamos C4 al visor
V1*)
7. se verifica si V1 puede ver a otros componentes, Si puede, entonces: (*V1 no ve
a ningún otro componente, el único componente nuevo se ha asignado a V1*).
8. fin

12
 Componentes
Referencia
mete-elemento, A
saca-elemento, A
tamaño-arreglo, MP
tamaño-cola, P
tope-pila, M
saca-pila, MA

Visores
1, 2, 3

Centros de Visores
C1+, C2, C3

Finalmente, para C5 tendremos:

1. n = 5; se verifica si las características de C5 existen como componentes

referencia.
1.1. Si existen, por tanto no se hace nada
2. desde i = 1 hasta 6 hacer:
2.1. sim(C5,R1) = 0; sim(C5,R2) = 0; sim(C5,R3) = 0,16; sim(C5,R4) = 0,16;
sim(C5,R5) = 0;
sim(C5,R6) = 0;
3. posición de C5 = (0 ; 0 ; 0,16; 0,16; 0; 0)
4. desde i = 1 hasta 3 hacer: (*para C5 se entra en este bucle 3 veces, porque
existen 3 visores*)
4.1. si 1 − sim( C5 , cv1 ) ≤ U (* 1 - sim(C5 , C1) = 1 - 0 = 1 > U *)
4.2. si 1 − sim( C5 , cv 2 ) ≤ U (* 1 - sim(C5 , C2) = 1 - 0,5 = 0,5 > U *)
4.3. si 1 − sim( C5 , cv 3 ) ≤ U (* 1 - sim(C5 , C3) = 1 - 0 = 1 > U *)
5. sino: (* creamos un nuevo visor*)
5.1. numvis = 4
5.2. hacemos cv4 = C5 = (0 ; 0 ; 0,16; 0,16; 0; 0)
5.3. se crea una nueva lista lcv (*la número 4*)
6. se añade el valor 5 en la lista lcv correspondiente (4) (*asignamos C5 al visor
V4*)
7. se verifica si V4 puede ver a otros componentes, Si puede, entonces: (*V4 no ve
a ningún otro componente, el único componente nuevo dio origen a V4*).
8. fin

13
 Componentes
Referencia
mete-elemento, A
saca-elemento, A
tamaño-arreglo, MP
tamaño-cola, P
tope-pila, M
saca-pila, MA

Visores
1, 2, 3, 4

Centros de Visores
C1+, C2, C3, C4

BIBLIOGRAFIA

1. Freeman P.: “reusable Software Engineering: Concepts and Research

Directions”. In Tutorial: Software Reusability, P. Freeman editor, IEEE
Computer Society Press, 1987, pp 10-23.

2. Frakes, Willian B.: “Software Reuse: Is Delivering? (Panel)”, Prceedings of the

13th Internatinal Conference on Software Engineering Austian, TX, 13 – 16 May
1991, pp. 52 - 59

3. Faustle; M.G. Fugini: Retrieval of reusable components using functional

similarity. Software-Practice and Experience, Vol. 26(5), May 1996. p.p.: 491-
530.

4. Hooper James. W., Chester Rowena O.:“Software Reuse Guidelines and

Methods”; Plenum Press, Febrero 1991, pp 2-4, 95-105

5. Marques Corral J. M.: “Soporte operativo para la reutilización del software:

repositorios y clasificación”; en Ingenieria del Software y Reutilización:
Aspectos Dinámicos y Generación Automática, J. L. Barros y A Domínguez,
Universidad de Vigo, Julio 1998 pp. 1;3;5;8;14-15

6. Pressman R. S.: “Ingeniería de software, un enfoque práctico” 4 Ed., Madrid,

McGraw Hill, 1998, pp 4 – 7 ; 581

7. Prieto-Diaz R.: Schafer W. Matsumoto M.,”Software Reusability” 1Ed, Ellis

Horwood Limited. 1994 pp.1

8. Soto Rodríguez Ivan, Representación y similitud de componentes software

mediante valores difusos, 2006, Trabajo de investigación –Dpto. de Estadística e
Informática , UNALM.

14