Está en la página 1de 299

UNIVERSIDAD DE ALMERA

Departamento de Lenguajes y Computacin






TESIS DOCTORAL


Algoritmos para el Procesamiento de Consultas
Espaciales utilizando R-trees. La Consulta de
los Pares Ms Cercanos y su Aplicacin en
Bases de Datos Espaciales


ANTONIO LEOPOLDO CORRAL LIRIA


Almera, Enero 2002




UNIVERSIDAD DE ALMERA
Departamento de Lenguajes y Computacin



TESIS DOCTORAL

Algoritmos para el Procesamiento de Consultas
Espaciales utilizando R-trees. La Consulta de
los Pares Ms Cercanos y su Aplicacin en
Bases de Datos Espaciales



Directores: Autor:




Dr. Yannis Manolopoulos Dr. Jos Samos Jimnez Antonio Leopoldo Corral Liria




UNIVERSIDAD DE ALMERA
ESCUELA POLITCNICA SUPERIOR



Departamento de Lenguajes y Computacin

Algoritmos para el Procesamiento de Consultas
Espaciales utilizando R-trees. La Consulta de
los Pares Ms Cercanos y su Aplicacin en
Bases de Datos Espaciales


Memoria presentada por Antonio Leopoldo Corral Liria para optar al grado de
Doctor en Informtica por la Universidad de Almera

Directores: Dr. Yannis Manolopoulos
Dr. Jos Samos

Almera, Enero 2002










a mi Rosa y a mi familia












What is understood need not be discussed
Loren Adams




i


Agradecimientos


Afortunadamente, son muchas las personas a las que debo agradecer el apoyo directo o
indirecto que me han prestado para que esta tesis se haya podido llevar a cabo.
En primer lugar, quisiera expresar mi ms sincero agradecimiento a Yannis Manolopoulos,
director de esta tesis, por la inestimable y generosa atencin que me ha prestado siempre. Sus
acertados consejos, ideas y comentarios, me han ayudado a hacer de este trabajo algo
agradable y gratificante. l es el principal responsable de la evolucin sufrida en mi carrera
como investigador. Tambin, mi gratitud a Jos Samos, director tambin de esta tesis, por su
apoyo, generosidad y dedicacin en la preparacin de esta memoria.
Agradezco tambin la ayuda y colaboracin prestada por Michalis Vassilakopoulos y
Yannis Theodoridis, cuyas ideas y consejos me han permitido mejorar considerablemente esta
tesis. Su visin rigurosa y experiencia en el tema, me han ayudado a despejar muchas dudas y
a plantear muchas de las extensiones reflejadas en este trabajo de investigacin. Tambin doy
las gracias a Jess Almendros, Jos Jess Fernndez y Julin Garca por su sentido crtico y
perfeccionista, de ayuda vital para la organizacin y elaboracin de esta memoria.
A Manuel Torres, mi compaero de despacho, con quien he compartido ms de cerca las
alegras de ver cumplidos los objetivos propuestos, agradezco su apoyo en todo momento y
sus consejos siempre bien acertados. A Alfonso Bosch, su confianza y ayuda en los momentos
difciles. A Samuel Tnez, por ofrecerme todo lo que ha tenido en sus manos para que esta
tesis se haya podido realizar. A Fernando Bienvenido, sin su confianza y apoyo nunca hubiese
empezado la carrera universitaria, ni hubiera realizado mi estancia en Salnica.
Debo extender mi gratitud a todos los compaeros del Departamento de Lenguajes y
Computacin de la Universidad de Almera, que me animaron en todo momento a sacar
adelante esta tesis y a hacer ms llevadera mi estancia en Salnica. Antonio Becerra, Luis
Iribarne, Rosa Ayala, Rafael Guirado, Francisco Rodrguez, Manuel Berenguel, Jos Carlos
Moreno, Joaqun Caadas, Francisco Guil, Jos Rafael Garca, Daniel Landa y Jordi
Rodrguez. A todos ellos les agradezco su sinceridad y amabilidad conmigo.
Tambin, agradezco al Data Engeeniring Laboratory del Department of Informatics de la
Aristotle University of Thessaloniki (Grecia), por haberme ayudado en todo momento a
desarrollar el trabajo fuera de casa. Alexandros Nanopoulos, Theodoros Tzouramanis, Eleni
Tousidou, Apostolos Papadopoulos y Dimitris Katzaros. A ellos les agradezco su paciencia
conmigo.
Agradecimientos
ii
Agradezco, al proyecto TMR europeo CHOROCHRONOS el soporte econmico recibido
para poder realizar la estancia en Salnica. Y al proyecto DAMOCIA, la posibilidad de
disfrutar de una beca de investigacin en la Universidad de Almera.
No puedo dejar de mencionar a toda mi familia, a la que durante tanto tiempo he
desatendido para poder realizar este trabajo. Mi gratitud a todos ellos por haber antepuesto su
compresin a la necesidad de tenerme con ellos. A mis padres, Luis y Carmen, a los que
realmente debo agradecer el poder hacer todo lo que hago. A mis hermanas, Maria e Inma,
agradezco el cario con el que siempre me han tratado y que durante estos aos no les he
podido corresponder.
Mi ltimo y ms profundo sentimiento de gratitud se lo dedico a Rosa, mi mujer, cuyo
amor y cario han sido siempre el sustento de todo mi trabajo. Su apoyo e infinita paciencia
han sido la clave para que este trabajo haya podido convertirse en realidad. De un modo u
otro, ella es la que da sentido a todo esto.



iii


Resumen


Los requerimientos de aplicaciones actuales de bases de datos, tales como GIS (sistemas de
informacin geogrfica), CAD (diseo asistido por ordenador), planificacin urbana,
mantenimiento de recursos naturales, sistemas multimedia, etc., imponen la necesidad de
gestionar datos de diferente naturaleza y de encontrar algoritmos para dar respuesta a
consultas que expresen la relacin que existe entre dichos datos. Para gestionar de forma
eficiente y rpida este gran volumen de datos se precisa del uso de mtodos de acceso. El
procesamiento de consultas sobre mtodos de acceso es un tema de investigacin emergente
tanto desde el punto de vista de los algoritmos que las implementan como de las estructuras
de datos que las soportan.
Un sistema de base de datos espacial es un sistema de base de datos que ofrece tipos de
datos espaciales en su modelo de datos y un lenguaje de consulta para manipularlos. En un
sistema informtico estos datos espaciales se representan por puntos, lneas, polgonos,
regiones, etc., que se les conoce con el nombre de objetos espaciales. Para responder a
consultas relacionadas con propiedades espaciales, se implementan algoritmos eficientes
sobre ndices espaciales creados a partir de esos objetos.
Cuando en una consulta intervienen objetos espaciales podemos preguntarnos acerca de
cul es la relacin espacial que existe entre ellos, por ejemplo, el join espacial sobre dos
conjuntos de objetos espaciales devuelve todos los pares de objetos que se solapan entre s,
donde cada elemento del par pertenece a un conjunto diferente. Otra relacin espacial es la
relacin de cercana, que representa el grado de proximidad entre los objetos espaciales, por
ejemplo, la consulta del vecino ms prximo encuentra, entre un conjunto de objetos
espaciales, el objeto ms prximo a uno previamente dado. La consulta basada en la relacin
de cercana entre dos conjuntos de objetos espaciales y que vamos a estudiar en esta tesis, la
vamos a denominar consulta de los pares ms cercanos.
Branch-and-bound (ramificacin y poda) es una tcnica general de diseo de algoritmos
utilizada para buscar la solucin ptima de un determinado problema. La idea principal
consiste en dividir el problema inicial en subproblemas parciales de tamao ms pequeo a
los que aplicamos heursticas de poda que permiten descartar el espacio de soluciones del
problema que no conduce a la solucin ptima. Esta tcnica se suele utilizar en el diseo de
algoritmos para consultas en bases de datos espaciales, recorriendo los mtodos de acceso
espaciales y calculando cotas relativas a soluciones parciales para limitar el nmero de
soluciones completas a examinar. En nuestro caso, los algoritmos que disearemos estarn
basados en esta tcnica y utilizarn heursticas de poda basadas en distancias para acotar el
espacio de bsqueda.
Resumen
iv
En esta tesis estudiamos algoritmos branch-and-bound y aplicamos tcnicas de
optimizacin sobre ellos para encontrar, dados dos conjuntos de objetos espaciales, los pares
de objetos espaciales ms cercanos, perteneciendo cada elemento del par a un conjunto
diferente. Dichos conjuntos de objetos espaciales se encuentran indexados en R-trees (mtodo
de acceso derivado del B-tree para gestionar informacin multidimensional), que son
estructuras de datos arbreas basadas en rectngulos minimales definidos por dos puntos y
con sus caras paralelas a los ejes de coordenadas (MBRs), balanceadas en altura y
almacenadas en disco. Los algoritmos branch-and-bound son apropiados para implementar
consultas sobre estas estructuras de datos arbreas, ya que aplicando heursticas de poda
basadas en propiedades intrnsecas a las consultas podemos obtener el resultado en tiempo
logartmico y empleando un reducido nmero de operaciones de E/S.
Los nicos trabajos que abordan la consulta de los pares ms cercanos lo hacen desde una
perspectiva incremental (devuelven los pares uno a uno en orden ascendente de distancia sin
determinar previamente la cardinalidad del resultado). Para responder a la misma consulta,
nosotros proponemos algoritmos branch-and-bound (recursivos e iterativos) desde una
perspectiva no incremental, debiendo proporcionar el nmero de pares ms cercanos deseado
antes de iniciar la consulta. Sobre estos ltimos algoritmos aplicamos tcnicas de
optimizacin para mejorarlos desde el punto de vista del tiempo de respuesta y del nmero de
accesos a disco. Tratamos de reducir el nmero de operaciones de E/S y el tiempo de
respuesta para satisfacer las necesidades de los usuarios, que requieren respuestas rpidas a
consultas complejas. En nuestro caso, vamos a aplicar estos algoritmos a conjuntos de objetos
espaciales (puntos) de dimensin dos, pero su extensin a conjuntos de objetos de
dimensiones mayores es sencilla.
Los principales resultados de esta tesis son los siguientes:
1. Se estudia y define la consulta del par ms cercano entre dos conjuntos de objetos en el
espacio Eucldeo k-dimensional, donde cada elemento del par pertenece a un conjunto
diferente. Esta nueva consulta se compara desde el punto de vista algortmico con la
consulta del vecino ms prximo y con el join espacial. Tambin, se presentan las
funciones de distancia entre pares de MBRs como base de las heursticas de poda
aplicadas en algoritmos branch-and-bound recursivos e iterativos.
2. Se presentan las heursticas de poda que aplicamos en algoritmos branch-and-bound,
siguiendo diferentes estrategias de bsqueda (en profundidad, primero el mejor, y en
anchura combinada con primero el mejor), para resolver la consulta del par ms
cercano. Con el objetivo de reducir el nmero de accesos a disco y el tiempo de
respuesta que son de gran importancia en la eficiencia de estos algoritmos, se definen e
implementan tcnicas de optimizacin, como por ejemplo, el Barrido del Plano.
3. Una vez establecidos los algoritmos branch-and-bound para llevar a cabo la consulta del
par ms cercano, se presentan varias extensiones del mismo junto con los detalles de
implementacin para que stos sean lo ms eficientes posible. Las extensiones
estudiadas son las siguientes: (1) tratamiento para R*-trees con diferentes alturas, (2)
caso en que en las hojas de los R*-trees se almacenen los MBRs de los objetos, (3)
variante para la consulta de los K pares ms cercanos (K-CPC), (4) obtener todos o los
K pares ms cercanos en un rango de distancia [Dist_Min, Dist_Max], (5) variantes para
Resumen
v
la consulta del par ms lejano (CPL) y de los K pares ms lejanos (K-CPL), (6) la Auto-
consulta y la Semi-consulta de los pares ms cercanos (Auto-CPC y Semi-CPC).
4. Todos los algoritmos branch-and-bound recursivos e iterativos para dar respuesta a la
consulta de los pares ms cercanos presentados en esta tesis han sido evaluados sobre
objetos espaciales (puntos) reales y sintticos, con el objetivo de medir y probar la
eficiencia de los mismos. Se han evaluado fundamentalmente respecto al nmero de
accesos a disco y tiempo total de respuesta requerido, aunque tambin se ha tenido en
cuenta para los algoritmos iterativos los recursos requeridos para evitar la recursividad.
Tambin se ha considerado en los experimentos, la presencia de buffers y la existencia
de diferentes porcentajes de solape entre las reas que cubren los conjuntos de datos. Se
ha realizado una comparativa con los algoritmos incrementales existentes y una
evaluacin de las extensiones ms representativas de dichos algoritmos.



vii


Abstract

The requirements of the modern database applications, such as GIS (Geographic Information
System), CAD (Computer Aided Design), urban planning, resource management, multimedia
systems etc, claim the need to manage different type of data and find efficient algorithms to
answer queries that express the relationship between such data. In order to manage efficiently
large volumes of data is necessary to use access methods. The processing of queries over
access methods is an emergent research topic from the point of view of the efficient
algorithms that implement such queries and the data structures that support them.
A spatial database system is a database system that offers spatial data types on its data
model and a query language to manage them. In a computer system these spatial data are
represented by points, lines, polygons, regions, etc, the so-called spatial objects. In order to
answer the queries related to spatial properties, efficient algorithms over spatial indexes,
created from these spatial objects, are implemented.
When spatial objects participate in a query, we can ask about the spatial relationship
among them. For example, a spatial join over two set of spatial objects returns all pairs of
objects that overlap between them, belonging each element of the pair to a different set.
Another spatial relation is the closeness relationship, which represents the proximity degree
between spatial objects. For example, the nearest neighbor query finds the spatial objects that
are near to a given object. The query based on the closeness relationship between two set of
spatial objects and we study in this thesis is called the closest pairs query. It discovers all
pairs of spatial objects that are close to each other.
Branch-and-bound is a general technique for the design of algorithms used to find the
optimal solution for a given problem. The underlying idea is to partition a given initial
problem into a number of intermediate partial subproblems of smaller sizes, applying pruning
heuristic in order to discard non-optimal solutions. This technique is used to design
algorithms for queries in spatial databases, traversing the spatial access methods, computing
relative bounds for partial subproblems, and reducing the search space significantly. In our
case, we show how bounding functions and searching strategies perform, when they are
included in branch-and-bound algorithms for a special distance-based query, the closest pairs
query.
In this thesis, we study branch-and-bound algorithms and apply optimization techniques in
order to find, given two sets of spatial objects, the closest pairs of spatial objects, belonging
each element to a different set. These spatial datasets are indexed in R-trees (access method
derived from B-tree for managing multidimensional information), that are hierarchical, height
balanced data structures based on minimum bounding rectangles defined for two points and
with faces parallel to the coordinate axis (MBR) and stored in disk. Branch-and-bound
algorithm are appropriate to implement queries on these tree-like structures, because using
Abstract
viii
pruning heuristics based on underlying properties of the queries we can get a solution in
logarithmic time using only a few number of I/O operations.
The only works about closest pairs query treat this kind of query in an incremental
perspective (returns the pairs one-by-one in ascending order of distance without knowing in
advance the cardinality of the result). To answer the same query, we propose branch-and-
bound algorithms (recursive and iterative) in a non-incremental way, giving the number of
desired closest pairs before the query starts. Also, we apply optimization techniques on these
algorithms in order to improve the response time and the number of disk accesses. We try to
reduce the number of I/O operations and response time, satisfying the requirements of the
users that demand fast answers to complex queries. In our case, we apply these branch-and-
bound algorithms to spatial datasets (2-dimensional points), but the extension to datasets of
objects with greater dimensions is straightforward.
The main results of this thesis are the following:
1. Study and define the closest pairs query between two sets of objects in the Euclidean k-
dimensional space, where every element of the pair belongs to a different set. This new
query is compared from an algorithmic point of view with the nearest neighbor query
and spatial join. Also, distance functions between pairs of MBRs are presented as basis
of pruning heuristics in branch-and-bound algorithms (recursive and iterative).
2. Pruning heuristics in branch-and-bound algorithms, with different searching strategies
(depth-first, best-first, and in breadth-first combine with best-first), for solving the
closest pair query are also presented. To reduce the number of disk accesses and the
response time, optimization techniques are defined and implemented. For instance, the
plane-sweep method.
3. Some extensions of the closest pairs query algorithms and their implementation details
are presented. Such extensions are the following: (1) treatment of R*-trees with
different heights, (2) the case in that the MBRs of the objects are stored on the R*-tree
leaf nodes, (3) extension for the K closest pairs query, (4) get all or K closest pairs in a
range of distance, (5) variants for the farthest pair query and its extension for the K
farthest pairs, (6) self and semi closest pairs.
4. All branch-and-bound algorithms (recursive and iterative) to solve the closest pair query
presented in this thesis have been evaluated using real spatial objects (points) and
synthetics, in order to measure and prove their efficiency. The evaluation is mainly
measured in terms of number of disk accesses and total response time required by them.
Moreover, the presence of buffers and different overlapping percentages between the
areas that cover the spatial datasets have been considered. A comparative study between
incremental algorithms (reporting the closest pairs incrementally) and the evaluation of
the most representative extensions have been carried out.



ix


ndice de Contenidos


Captulo 1 INTRODUCCIN ....................................................................................... 1

1.1 Introduccin ..................................................................................................... 1
1.2 mbito y motivacin ....................................................................................... 3
1.3 Objetivos de la tesis ....................................................................................... 4
1.4 Contribuciones ................................................................................................ 5
1.5 Descripcin del contenido ............................................................................. 5


Captulo 2 MTODOS DE ACCESO ESPACIALES BASADOS EN MBRs.
R*-TREE ..................................................................................................... 9

2.1 Introduccin ..................................................................................................... 9
2.2 Mtodos de acceso multidimensionales. Una revisin ................................... 10
2.2.1 Mtodos de acceso multidimensionales basadas en memoria principal ...... 11
2.2.2 Mtodos de acceso basados en almacenamiento secundario .................... 12
2.2.2.1 Mtodos de acceso a puntos ............................................................... 13
2.2.2.2 Mtodos de acceso espaciales .......................................................... 14
2.3 Modelo de organizacin de ndices basados en MBRs en el espacio de
datos k-dimensional ....................................................................................... 16
2.4 La familia de los R-trees k-dimensionales como mtodo de acceso
espacial basado en MBRs ............................................................................. 20
2.5 Consultas espaciales ....................................................................................... 24
2.6 R*-tree .............................................................................................................. 29
2.6.1 El R-tree como base para el R*-tree .......................................................... 29
2.6.2 Caractersticas principales del R*-tree ...................................................... 33
2.6.3 Algoritmos para el mantenimiento de un R*-tree ....................................... 35
2.6.3.1 Algoritmo de insercin .................................................................... 35
2.6.3.2 Algoritmo de borrado ......................................................................... 40
2.6.3.3 Algoritmo de bsqueda .................................................................... 41
2.6.4 Algoritmos para el procesamiento de consultas utilizando R*-trees como
mtodo de acceso espacial ......................................................................... 42
2.6.4.1 Etapas en el procesamiento de consultas espaciales utilizando R*-
trees ..................................................................................................... 42

ndice de contenidos
x

2.6.4.2 Algoritmos para el procesamiento de consultas espaciales utilizando
R*-trees ................................................................................................ 44
2.6.4.2.1 Algoritmos para la consulta exacta ............................................ 44
2.6.4.2.2 Algoritmos para la consulta en rango ....................................... 45
2.6.4.2.3 Algoritmos para la consulta del vecino ms prximo ................ 46
2.6.4.2.4 Algoritmos para determinar el join espacial .............................. 49
2.7 Conclusiones ..................................................................................................... 57


Captulo 3 CONSULTAS DE LOS PARES MS CERCANOS .............................. 59

3.1 Introduccin ..................................................................................................... 59
3.2 La consulta del par ms cercano y su extensin a los K pares ms
cercanos .......................................................................................................... 60
3.2.1 Mtricas ..................................................................................................... 60
3.2.2 El par ms cercano de un conjunto de puntos ............................................ 62
3.2.3 Definicin de la consulta del par ms cercano y su extensin a los K pares
ms cercanos ................................................................................................ 64
3.2.4 Ejemplos de aplicacin de las consultas de los pares ms cercanos sobre
datos espaciales ........................................................................................... 66
3.3 Las consultas join y el vecino ms prximo, como base para las consultas
de los pares ms cercanos ............................................................................. 70
3.3.1 Join utilizando R*-trees ............................................................................. 70
3.3.2 La consulta del par ms cercano utilizando R*-trees ................................... 71
3.4 Mtricas entre pares de MBRs para el procesamiento de las consultas de
los pares ms cercanos .................................................................................. 76
3.5 Conclusiones ..................................................................................................... 90


Captulo 4 ALGORITMOS PARA LA REALIZACIN DE LA CONSULTA
DEL PAR MS CERCANO UTILIZANDO R*-TREES .................... 93

4.1 Introduccin ..................................................................................................... 93
4.2 Primeras aproximaciones para dar solucin a la consulta del par ms
cercano utilizando R*-trees ......................................................................... 94
4.2.1 Recorridos de un R*-tree ............................................................................. 94
4.2.1.1 Recorrido en profundidad de un R*-tree ............................................ 95
4.2.1.2 Recorrido en anchura de un R*-tree ................................................. 95
4.2.2 Algoritmo que combina un recorrido de un R*-tree con una consulta del
vecino ms prximo sobre el otro R*-tree ................................................. 96
4.2.3 Algoritmo recursivo siguiendo un esquema de join en bucle anidado sobre
dos R*-trees ................................................................................................ 97
4.2.4 Algoritmo iterativo sobre dos R*-trees utilizando un montculo ................ 98
4.2.4.1 Montculos ....................................................................................... 99
4.2.4.2 Algoritmo iterativo utilizando un montculo ....................................... 102

ndice de contenidos
xi

4.3 Algoritmos branch-and-bound para determinar el par ms cercano.
Formas de procesamiento y reglas de poda ................................................. 104
4.3.1 Algoritmos branch-and-bound .................................................................... 104
4.3.2 Formas de procesamiento en algoritmos branch-and-bound para encontrar
el par ms cercano ....................................................................................... 108
4.3.3 Reglas de poda basadas en distancias para los algoritmos branch-and-
bound que determinan el par ms cercano ................................................. 111
4.4 Algoritmos branch-and-bound recursivos para encontrar el par ms
cercano .............................................................................................................. 112
4.4.1 Algoritmo branch-and-bound recursivo MINMINDIST .............................. 112
4.4.2 Algoritmo branch-and-bound recursivo MINMAXDIST_MINMINDIST .. 113
4.4.3 Algoritmo branch-and-bound recursivo MINMAXDIST_MINMINDIST
Ordenado ..................................................................................................... 115
4.4.4 Algoritmo branch-and-bound recursivo utilizando la tcnica de Barrido del
Plano .............................................................................................................. 118
4.5 Algoritmos branch-and-bound iterativos utilizando un montculo para
encontrar el par ms cercano ......................................................................... 124
4.5.1 Algoritmo branch-and-bound iterativo MINMINDIST utilizando un
montculo ..................................................................................................... 124
4.5.2 Algoritmo branch-and-bound iterativo MINMAXDIST_MINMINDIST
utilizando un montculo ............................................................................. 126
4.5.3 Algoritmo branch-and-bound iterativo MINMAXDIST_MINMINDIST
Ordenado utilizando un montculo ............................................................... 127
4.5.4 Algoritmo branch-and-bound iterativo utilizando la tcnica de Barrido del
Plano y un montculo .................................................................................. 130
4.5.5 Algoritmo branch-and-bound iterativo basado en un recorrido en anchura y
utilizando una lista de montculos ............................................................... 132
4.6 Comparativa con otros algoritmos que determinan el par ms cercano
utilizando R*-trees ....................................................................................... 135
4.7 Conclusiones ..................................................................................................... 137


Captulo 5 EXTENSIONES DE LOS ALGORITMOS Y DETALLES DE
IMPLEMENTACIN ............................................................................. 139

5.1 Introduccin ..................................................................................................... 139
5.2 Tratamientos para R*-trees con diferentes alturas ................................... 140
5.3 Extensin de los algoritmos para el caso en que las hojas de los R*-trees
almacenen MBRs de los objetos .................................................................... 147
5.4 Extensin de los algoritmos para la consulta de los K pares ms cercanos. 149
5.5 Extensin de los algoritmos para obtener los K pares ms cercanos en un
rango de distancia [Dist_Min, Dist_Max] ...................................................... 157
5.6 Extensin de los algoritmos para realizar la consulta del par ms lejano y
de los K pares ms lejanos ............................................................................. 160
5.7 Auto-consulta de los pares ms cercanos (Auto-CPC) .............................. 163
5.8 Semi-consulta de los pares ms cercanos (Semi-CPC) .............................. 166
5.9 Conclusiones ..................................................................................................... 169

ndice de contenidos
xii


Captulo 6 RESULTADOS EXPERIMENTALES Y APLICACIN .................... 171

6.1 Introduccin ..................................................................................................... 171
6.2 Resultados experimentales para CPC y K-CPC ............................................ 172
6.2.1 Objetivos ..................................................................................................... 172
6.2.2 Definicin de los experimentos .................................................................... 173
6.2.3 Presentacin y anlisis de resultados .......................................................... 175
6.2.4 Conclusiones ................................................................................................ 194
6.3 Utilizacin de R*-trees con diferentes alturas ............................................ 195
6.4 Efecto del porcentaje de solape entre los conjuntos de datos .................... 202
6.5 Inclusin de un buffer de pginas con una poltica de reemplazo LRU .. 212
6.6 Comparacin con la alternativa incremental ................................................. 224
6.7 Auto-CPC y Semi-CPC .................................................................................. 232
6.8 Conclusiones de la experimentacin ............................................................... 236


Captulo 7 CONCLUSIONES Y TRABAJO FUTURO ............................................ 239

7.1 Conclusiones ..................................................................................................... 239
7.2 Lneas de trabajo futuro .................................................................................. 242


REFERENCIAS .......................................................................................................... 245


APNDICE A .............................................................................................................. 259




xiii


ndice de Figuras


2.1 Ejemplo de un k-d-tree (orden de insercin: p1, p2, p3, p4, p5, p6) ................ 11
2.2 Ejemplo de un B-tree (orden de insercin: 8, 5, 1, 7, 3, 12, 9, 8) ..................... 14
2.3 Ejemplo en una, dos y tres dimensiones de un n-rectngulo definido por dos
puntos ............................................................................................................... 19
2.4 MBRs de uno o ms objetos ............................................................................. 22
2.5 Un ejemplo de R-tree ....................................................................................... 30
2.6 Alternativas para la divisin de un nodo que ha excedido su capacidad
mxima ............................................................................................................... 31
2.7 Un ejemplo de R*-tree ....................................................................................... 34
2.8 Solape de R en N ................................................................................................ 35
2.9 Insercin del MBR R9 ....................................................................................... 38
2.10 Distribucin de los MBRs y el R*-tree asociado despus de insertar el MBR
R9 ................................................................................................................... 39
2.11 Bsqueda en rango para MBRs de objetos que se solapan con S ..................... 42
2.12 Procesamiento de consultas espaciales en dos etapas ........................................ 43
3.1 Dos conjuntos de puntos en E
(2)
......................................................................... 66
3.2 MinDist, MinMaxDist y MaxDist entre un punto p y los MBRs R
1
y R
2
en E
(2)
74
3.3 Aplicacin de la estrategia de poda para encontrar el vecino ms prximo ...... 75
3.4 MinMinDist(R
i
, R
j
) entre dos MBRs en E
(2)
...................................................... 77
3.5 Propiedad de MinMinDist en una dimensin en E
(2)
........................................ 80
3.6 Propiedad de MinMinDist sobre MBRs en E
(2)
................................................. 80
3.7 Propiedad de las caras de un MBR en un R*-tree ............................................ 81
3.8 MinimaMaximaDistancia(R
i
, R
j
) entre dos MBRs en E
(2)
.............................. 83
3.9 Distancias entre las caras a
1
y b
1
para calcular MinimaMaximaDistancia(R
1
,
R
2
) ................................................................................................................... 83
3.10 MinimaMaximaDistancia(R
1
, R
2
) y MinMaxDist(R
1
, R
2
) entre dos MBRs en
E
(2)
................................................................................................................... 87
3.11 MaxMaxDist(R
i
, R
j
) entre dos MBRs en E
(2)
...................................................... 88
3.12 MinMinDist, MinMaxDist y MaxMaxDist entre dos MBRs R
1
y R
2
en E
(2)
...... 90
4.1 rbol binario esencialmente completo .......................................................... 99
4.2 Ejemplo de montculo ....................................................................................... 100
4.3 Representacin de un montculo como estructura de datos .............................. 101
4.4 Aplicacin de las estrategias de poda para encontrar el par ms cercano ...... 112
4.5 Distancias entre dos MBRs para el algoritmo
CPC_Recursivo_MINMAXDIST_MINMINDIST ............................................ 115
4.6 Procesamiento de pares de MBRs con la tcnica de Barrido del Plano ........... 119

ndice de figuras
xiv

4.7 Efecto de la seleccin de un eje de barrido ...................................................... 120
4.8 Tres tipos de pares de MBRs proyectados sobre el eje de barrido ..................... 121
4.9 Estructura de una lista de montculos mnimos organizada por niveles ........... 132
5.1 Posibles casos para dos R*-trees (R
P
y R
Q
) con diferentes alturas ..................... 140
5.2 Modelos de organizacin para almacenar objetos en un R*-tree segn
[BrK94a, BHK
+
93] ............................................................................................ 148
5.3 Estructuras de datos adicionales para el procesamiento de los K pares ms
cercanos (K-CPC) sobre algoritmos recursivos ................................................. 149
5.4 Estructuras de datos adicionales para el procesamiento de los K pares ms
cercanos (K-CPC) sobre algoritmos iterativos ................................................. 154


5.5 Tabla hash organizada por listas enlazadas asociada a un montculo mximo
de pares de MBRs (MMMD), utilizando como clave para la organizacin de
la misma, la mtrica MaxMaxDist .................................................................... 155
5.6 Estructuras de datos adicionales para obtener los K pares ms cercanos que
estn en un rango de distancia [Dist_Min, Dist_Max] ................................... 158
5.7 Estructuras de datos para el procesamiento de Auto-CPC y Auto-K-CPC ...... 163


5.8 Tabla hash organizada por listas enlazadas vinculada a un montculo mnimo
de pares de puntos (KMasCercanos), utilizando como clave de ordenacin la
distancia Eucldea entre ellos ............................................................................. 165
5.9 Estructuras de datos para el procesamiento de Semi-CPC .............................. 167
5.10 Estructuras de datos para el procesamiento de Semi-CPC utilizando la
variante GlobalTodos, donde X = nmero de MBRs en el R*-tree R
P
........... 168
6.1 Figura con ejemplos de los conjuntos de puntos (California), reales y reales
movidos aleatoriamente .................................................................................. 174
6.2 K-CPC para algoritmos recursivos (RECU_EXH y RECU_STD) e iterativos
(HEAP_SIM y BFT_SIM) ............................................................................. 177
6.3. Coste relativo de RECU_STD, HEAP_SIM y BFT_SIM respecto a
RECU_EXH ..................................................................................................... 178
6.4 CPC, combinando puntos reales con reales movidos aleatoriamente ................ 186


6.5. Comportamiento de K-CPC para los algoritmos recursivos e iterativos,
cuando combinamos puntos reales con reales movidos aleatoriamente y de
cardinalidades diferentes .................................................................................. 187


6.6 Comportamiento de K-CPC para RECU_EXH, RECU_STD, HEAP_SIM y
BFT_SIM para puntos reales y reales movidos aleatoriamente (60K = 60000
puntos) ............................................................................................................... 187
6.7 Tiempo de respuesta para K-CPC aplicado a las mejores alternativas
recursivas e iterativas ....................................................................................... 193


6.8 K-CPC para algoritmos recursivos e iterativos (variante STD) sobre R*-trees
con diferentes alturas, utilizando las tcnicas de Fijar las Hojas (FH) y Fijar
la Raz (FR) ..................................................................................................... 197
6.9 Tiempo de respuesta en segundos para CPC, sobre R*-trees con diferentes
alturas ............................................................................................................... 200
6.10 Tiempo de respuesta para K-CPC aplicado a las mejores alternativas
recursivas e iterativas ....................................................................................... 202
6.11 Nmero de accesos a disco para CPC para algoritmos recursivos e iterativos
con puntos aleatorio/uniforme ......................................................................... 204

ndice de figuras
xv





6.12 Coste relativo de K-CPC para los algoritmos recursivos (RECU_SIM,
RECU_STD y RECU_PS) e iterativo (HEAP) tomando como referencia
RECU_EXH respecto al incremento de K y del porcentaje de solape entre las
reas que cubren los conjuntos de datos (puntos reales combinados con reales
movidos aleatoriamente) con la misma cardinalidad ........................................ 205


6.13 Tiempo de respuesta en segundos para CPC sobre los algoritmos recursivos e
iterativos en su variante PS, sobre R*-trees procedentes de la indexacin de
puntos reales y reales movidos aleatoriamente ................................................. 208


6.14 Tiempo de respuesta para K-CPC (K = 10 y K = 1000000) aplicado a las
mejores alternativas recursivas e iterativas respecto al incremento del
porcentaje de solape entre las reas que cubren los conjuntos de datos ........... 211
6.15 Arquitectura estndar de una base de datos para el procesamiento de consultas 213
6.16 Esquema de buffer Local para la consulta de los pares ms cercanos ................ 215
6.17 Estructura de datos de un buffer de pginas almacenado en memoria (buffer
pool) ................................................................................................................... 215
6.18 Estructura de un path-buffer asociado a un R*-tree ........................................ 217


6.19 Efecto de incluir un buffer de pginas de tamao variable al aplicar el
algoritmo recursivo (RECU_STD) y el iterativo (HEAP_STD) para obtener el
par ms cercano (CPC) ....................................................................................... 218
6.20 Nmero de accesos a disco del algoritmo recursivo (RECU_STD) para K-
CPC utilizando un buffer de pginas LRU de tamao variable ......................... 219
6.21 Nmero de accesos a disco del algoritmo iterativo (HEAP_PS) para K-CPC
utilizando un buffer de pginas LRU de tamao variable .............................. 220
6.22 Porcentaje de ahorro para K-CPC con el algoritmo recursivo (RECU_STD),
variando el tamao del buffer (B > 0) con respecto a B = 0 .............................. 221
6.23 Porcentaje de ahorro para K-CPC con el algoritmo iterativo (HEAP_PS),
variando el tamao del buffer (B > 0) con respecto a B = 0 .............................. 221


6.24 Nmero de accesos a disco para K-CPC utilizando los algoritmos, recursivo
(RECU_STD) e iterativo (HEAP_PS), fijando el tamao del buffer (B = 512)
y tomando como parmetro variable el valor de K ............................................ 222
6.25 Esquema de buffer Global para la consulta de los pares ms cercanos ........... 223


6.26 Nmero de accesos a disco de los algoritmos incrementales y los no
incrementales (recursivo e iterativo) en su variante STD, para K-CPC
teniendo presente un buffer LRU de 512 pginas ............................................ 228


6.27 Tiempo de respuesta en segundos para K-CPC sobre los algoritmos
incrementales y no incrementales (recursivo e iterativo en su variante PS),
utilizando un buffer LRU de 512 pginas .......................................................... 230


6.28 Nmero de accesos a disco de la variante STD en los algoritmos recursivo e
iterativo, para Auto-K-CPC, utilizando un buffer LRU con 512 pginas y en
ausencia del mismo ............................................................................................ 233
6.29 Tiempo de respuesta en segundos para Auto-K-CPC sobre la variante PS de
los algoritmos recursivo e iterativo, utilizando un buffer LRU de 512 pginas. 234



xvii


ndice de Tablas


2.1 Clasificacin general de los mtodos de acceso basados en almacenamiento
secundario .......................................................................................................... 12
2.2 Clasificacin de los mtodos de acceso ms representativos de la familia del
R-tree k-dimensional ....................................................................................... 24
2.3 Clasificacin de los mtodos de join espacial ................................................. 52


4.1 Comparativa entre algoritmos iterativos, incrementales y no incrementales
para obtener el par ms cercano utilizando R*-trees como mtodo de
indexacin .......................................................................................................... 136
6.1 Nmero de accesos a disco para CPC ............................................................... 176
6.2 Nmero de accesos a disco para K-CPC .......................................................... 177
6.3 Tamao mximo del montculo principal para K-CPC (HEAP), considerando
y sin considerar MaxMaxDist ......................................................................... 179
6.4 Nmero de inserciones en el montculo principal para K-CPC (HEAP),
considerando y sin considerar MaxMaxDist ...................................................... 179


6.5 Nmero de accesos a disco para K-CPC utilizando RECU_EXH,
RECU_STD, HEAP_SIM y BFT_SIM para puntos reales y reales movidos
aleatoriamente ..................................................................................................... 187
6.6 Tamao mximo del montculo, considerando y sin considerar un tratamiento
de empates .......................................................................................................... 188
6.7 Nmero de inserciones en el montculo principal, considerando y sin
considerar un tratamiento de empates ............................................................... 189
6.8 Tamao mximo del montculo principal, para HEAP y BFT ......................... 189
6.9 Nmero de inserciones en el montculo principal, para HEAP y BFT ........... 190
6.10 Tiempo de respuesta en segundos para CPC ...................................................... 190
6.11 Tiempo de respuesta en segundos para K-CPC sin considerar MaxMaxDist ni
el tratamiento de empates .................................................................................. 191
6.12 Tiempo de respuesta en segundos para K-CPC considerando MaxMaxDist y
el tratamiento de empates .................................................................................. 192
6.13 Tiempo de respuesta en segundos para K-CPC sin considerar MaxMaxDist ni
el tratamiento de empates .................................................................................. 192
6.14 Nmero de accesos a disco para CPC sobre R*-trees con diferentes alturas .. 196
6.15 Nmero de accesos a disco para K-CPC sobre R*-trees con diferentes alturas,
aplicando algoritmos recursivos e iterativos en su variante STD ..................... 197
6.16 Tamao mximo del montculo para CPC utilizando el algoritmo iterativo
HEAP, considerando y sin considerar tcnicas de optimizacin ..................... 198

ndice de tablas
xviii

6.17 Nmero de inserciones en el montculo para CPC utilizando el algoritmo
iterativo HEAP, considerando y sin considerar tcnicas de optimizacin ...... 198
6.18 Tamao mximo del montculo para K-CPC empleando el algoritmo iterativo
HEAP, utilizando Fijar las Hojas (FH) y Fijar la Raz (FR) ......................... 199
6.19 Nmero de inserciones en montculo para K-CPC empleando el algoritmo
iterativo HEAP, utilizando Fijar las Hojas (FH) y Fijar la Raz (FR) ........... 199
6.20 Tiempo de respuesta en segundos para CPC, sobre R*-trees con diferentes
alturas ............................................................................................................... 200
6.21 Tiempo de respuesta en segundos para K-CPC, sobre R*-trees con diferentes
alturas ............................................................................................................... 201
6.22 Nmero de accesos a disco para CPC sobre R*-trees procedentes de la
indexacin de puntos reales y reales movidos aleatoriamente ......................... 203


6.23 Nmero de accesos a disco para CPC, utilizando R*-trees procedentes de la
indexacin de puntos sintticos generados aleatoriamente y siguiendo una
distribucin uniforme ....................................................................................... 203
6.24 Tiempo de respuesta en segundos para CPC, sobre R*-trees procedentes de la
indexacin de puntos reales y reales movidos aleatoriamente ......................... 207


6.25 Tiempo de respuesta en segundos para K-CPC utilizando los algoritmos
recursivos e iterativos, sobre R*-trees procedentes de la indexacin de puntos
reales y reales movidos aleatoriamente con diferente porcentaje de solape ...... 208
6.26 Porcentaje de ahorro que supone incluir un path-buffer en los algoritmos para
K-CPC ............................................................................................................... 217



6.27 Nmero de accesos a disco y porcentaje de ahorro del algoritmo recursivo
(RECU_STD) respecto del iterativo (HEAP_STD) para CPC, utilizando un
buffer de pginas de tamao variable (0 B 1024) y gestionado con una
poltica LRU ..................................................................................................... 218
6.28 Nmero de accesos a disco del algoritmo recursivo (RECU_STD) para K-
CPC utilizando un buffer de pginas LRU de tamao variable (0 B 1024). 219
6.29 Nmero de accesos a disco del algoritmo iterativo (HEAP_PS) para K-CPC
utilizando un buffer de pginas LRU de tamao variable (0 B 1024) ...... 220



6.30 Nmero de accesos a disco del algoritmo recursivo (RECU_STD) e iterativo
(HEAP_PS) para K-CPC utilizando un buffer LRU de tamao fijo (B = 512)
y siendo variable el valor de K. Comparativa del porcentaje de ahorro del
recursivo frente al iterativo ............................................................................. 222


6.31 Nmero de accesos a disco de los algoritmos incrementales y los no
incrementales (recursivo e iterativo) en su variante STD para K-CPC, no
teniendo presenta un buffer LRU (B = 0) .......................................................... 226


6.32 Nmero de accesos a disco de los algoritmos incrementales y los no
incrementales (recursivo e iterativo) en su variante STD, para K-CPC
teniendo presente un buffer LRU de 512 pginas (B = 512) .............................. 227


6.33 Nmero mximo de pares en memoria principal de los algoritmos iterativos
incrementales y los no incrementales en su variante STD (HEAP_STD), para
K-CPC ............................................................................................................... 229


6.34 Nmero de pares insertados en la cola de prioridad de los algoritmos
incrementales y en el montculo mnimo principal de los no incrementales e
iterativos en su variante STD, para K-CPC ...................................................... 229

ndice de tablas
xix




6.35 Tiempo de respuesta en segundos para K-CPC sobre los algoritmos
incrementales y no incrementales (recursivo e iterativo en su variante PS),
sobre R*-trees procedentes de la indexacin de puntos reales y reales
movidos aleatoriamente, y utilizando un buffer LRU de 512 pginas ........... 230
6.36 Nmero de accesos a disco de las mejores variantes de los algoritmos
recursivos e iterativos, para Auto-K-CPC, en ausencia buffer ......................... 232


6.37 Nmero de accesos a disco de las mejores variantes de los algoritmos
recursivos e iterativos, para Auto-K-CPC, utilizando un buffer LRU con 512
pginas ............................................................................................................... 232


6.38 Tiempo de respuesta en segundos para Auto-K-CPC sobre los algoritmos
recursivo e iterativo, utilizando un buffer LRU de 512 pginas (256 para cada
uno de los rboles) ............................................................................................ 233



6.39 Nmero de accesos a disco para las adaptaciones GlobalObjetos (GO) y
GlobalTodos (GT) de los algoritmos recursivos e iterativos, junto con
R+CVP, para la Semi-CPC, sin utilizar y utilizando un buffer LRU con 512
pginas ............................................................................................................... 234



6.40 Tiempo total de respuesta en segundos para las adaptaciones GlobalObjetos
(GO) y GlobalTodos (GT) de los algoritmos recursivos e iterativos, junto con
R+CVP, para la Semi-CPC, sin utilizar y utilizando un buffer LRU con 512
pginas ............................................................................................................... 235


xxi


Glosario de Abreviaciones


BAS Variante Basic de los algoritmos incrementales
BFRJ Breadth-First R-tree Join
BFT Breadth-First Traversal. Algoritmo branch-and-bound iterativo para
encontrar los pares ms cercanos basado en un recorrido en anchura
utilizando una lista de montculos mnimos siguiendo en cada uno de ellos
una estrategia de bsqueda con una funcin de seleccin de primero el mejor
BRU Algoritmo para encontrar los pares ms cercanos, sin tener en cuenta ningn
criterio de poda
CA Consulta de Adyacencia
CAD Diseo Asistido por Ordenador
CCu Consulta de Cubrimiento
CE Consulta Exacta
CIn Consulta de Inclusin
CLP Consulta para la Localizacin de un Punto
CPC Consulta del Par ms Cercano
CPL Consulta del Par ms Lejano
CR Consulta en Rango
CS Consulta de Solape
CVP Consulta del Vecino ms Prximo
EVN Variante Evenly de los algoritmos incrementales
EXH Variante de los algoritmos branch-and-bound para encontrar los pares ms
cercanos, utilizando slo la heurstica de poda basada en MinMinDist
FH Fijar las Hojas para el tratamiento de R*-trees con diferentes alturas
FR Fijar la Raz para el tratamiento de R*-trees con diferentes alturas
GIS Sistemas de Informacin Geogrfica
GO Variante GlobalObjetos para Semi-CPC
GT Variante GlobalTodos para Semi-CPC
HEAP Algoritmo branch-and-bound iterativo para encontrar los pares ms cercanos
utilizando un montculo mnimo global con una estrategia de bsqueda
basada en una funcin de seleccin de primero el mejor
JE Join Espacial
K-CPC Consulta de los K Pares ms Cercanos
K-CPL Consulta de los K Pares ms Lejanos
K-CVP Consulta de los K Vecinos ms Prximos
LRU Last Recently Used. Poltica de reemplazo de pgina que sustituye la pgina
menos recientemente utilizada

Glosario de abreviaciones
xxii

MAE Mtodos de Acceso Espaciales
MAP Mtodos de Acceso a Puntos
MaxDist Funcin que representa la mxima distancia de un punto a un MBR
MaxMaxDist Funcin que representa la mxima distancia que hay entre dos MBRs
MBR Minimum Bounding Rectangle. Mnima envolvente rectangular que cubre a
un objeto o a un conjunto de objetos, definida por dos puntos y con sus caras
paralelas a los ejes de coordenadas
MinDist Funcin que representa la mnima distancia de un punto a un MBR
MinMaxDist Funcin que representa la mnima de todas las mximas distancias entre las
caras paralelas ms prximas de dos MBRs para cada una de las
dimensiones. Tambin, representa el mnimo valor de todas las mximas
distancias entre un punto y un MBR sobre cada una de las dimensiones
MinMinDist Funcin que representa la mnima distancia que hay entre dos MBRs
PS Variante de los algoritmos branch-and-bound para encontrar los pares ms
cercanos, utilizando la tcnica del barrido del plano
RECU Algoritmo branch-and-bound recursivo para encontrar los pares ms
cercanos siguiendo una estrategia de bsqueda en profundidad
R+CVP Algoritmo que aplica un recorrido en profundidad en un R*-tree combinado
con una consulta del vecino ms prximo en otro R*-tree
R+KCVP Algoritmo que aplica un recorrido en profundidad en un R*-tree combinado
con una consulta de los K vecinos ms prximos en otro R*-tree
SIM Variante de los algoritmos branch-and-bound para encontrar los pares ms
cercanos, considerando MinMaxDist y MinMinDist en CPC y, MaxMaxDist
y MinMinDist para K-CPC
SML Variante Simultaneous de los algoritmos incrementales
STD Variante de los algoritmos branch-and-bound para encontrar los pares ms
cercanos, ordenando en base a MinMinDist en una lista local todos los
posibles pares de MBRs procedentes de la combinacin de dos nodos
internos
STM Variante de los algoritmos branch-and-bound para encontrar los pares ms
cercanos, ordenando en base a MinMinDist en un montculo mnimo local
todos los posibles pares de MBRs procedentes de la combinacin de dos
nodos internos
SGBD Sistema de Gestin de Base de Datos
SGBDE Sistemas de Gestin de Bases de Datos Espaciales



1


Captulo 1


INTRODUCCIN




1.1 Introduccin

Los sistemas actuales de bases de datos han experimentado un crecimiento importante en el
volumen de datos a procesar. Este crecimiento ha venido provocado en gran medida como
consecuencia de la fuerte competencia existente en distintos sectores de la economa, lo que
hace a las empresas manejar grandes cantidades de informacin para facilitar la toma de
decisiones de forma rpida. Por ello, las aplicaciones actuales de bases de datos tales como
GIS (sistemas de informacin geogrfica), CAD (diseo asistido por ordenador), multimedia
y otras, imponen unas exigencias en el procesamiento eficiente de consultas.
Un sistema de base de datos espacial es un sistema de base de datos capaz de gestionar
informacin de naturaleza espacial y ofrecer un lenguaje de consulta para su manipulacin
[Gt94]. Dicha informacin se representa mediante un modelo de datos espacial, como por
ejemplo el propuesto en [ArS91].
En un sistema informtico los datos espaciales se representan por puntos, lneas, polgonos,
regiones, etc., que se les conoce con el nombre de objetos espaciales [Sam90a]. Estas bases de
datos se incluyen en sistemas especializados tales como sistemas de informacin geogrfica
(GIS), diseo asistido por ordenador (CAD), sistemas multimedia, etc. El papel de las bases
de datos espaciales est presente en muchas aplicaciones de la vida moderna, como pueden
ser: planificacin urbana, gestin de recursos, modelado ambiental, etc. [Sam90b].
Uno de los principales objetivos de un sistema de gestin de bases de datos es proporcionar
mtodos de acceso y algoritmos eficientes para el procesamiento de consultas [Gt94]. Para
aumentar el rendimiento de dicho sistema (evaluado principalmente respecto al tiempo de
Captulo 1
2
respuesta y nmero de accesos a disco) surgen los mtodos de acceso [GaG98]. Los ndices
unidimensionales (estructuras de datos de clave nica) ms estudiados han sido el B-tree
[BaM72] y sus derivados (B
+
-tree [Com79], B*-tree, etc.). A un grupo de ndices derivado del
B-tree para gestionar informacin multidimensional se le conoce con el nombre de familia de
R-trees (estructuras de datos arbreas basadas en rectngulos minimales definidos por dos
puntos y con sus caras paralelas a los ejes de coordenadas (MBRs), balanceadas en altura y
almacenadas en disco), entre los cuales estn el R-tree original [Gut84], R
+
-tree [SRF87], R*-
tree[BKS
+
90], X-tree [BKK96], etc.
Para aumentar el rendimiento en la recuperacin de los objetos espaciales se pueden definir
ndices espaciales. Dichos ndices representan la ubicacin de los objetos espaciales que estn
almacenados en la base de datos. Sin embargo, para simplificar el manejo de dichos ndices se
suele utilizar algn tipo de aproximacin de los objetos espaciales. El mnimo rectngulo
envolvente o MBR de esos objetos espaciales es la aproximacin ms utilizada [BKS93b,
BrK94b]. Dichos MBRs representan la clave de indexacin que se utiliza para generar los
ndices que pertenecen a la familia de R-trees. En particular, el R*-tree [BKS
+
90] es uno de
los mtodos de acceso que ha demostrado ser muy eficiente sobre datos espaciales, mejorando
notablemente al R-tree original [Gut84]. El procesamiento eficiente de consultas sobre
mtodos de acceso espaciales (entre los que se encuentra el R*-tree y que estudiaremos en
esta tesis) est siendo investigado tanto desde el punto de vista de los algoritmos que las
implementan como desde la optimizacin de las estructuras de datos que las soportan.
La caracterstica principal que hace de un sistema de base de datos espacial una
herramienta potente es su capacidad de procesar datos espaciales, incluso ms que la
representacin y almacenamiento de los mismos [YuM98]. La forma ms eficiente de
gestionar dichos datos es responder a consultas relacionadas con propiedades espaciales. Las
consultas espaciales ms conocidas son las siguientes:
1. Consulta exacta, que busca un objeto espacial determinado en un conjunto de objetos
espaciales [Sam90a].
2. Consulta en rango, que busca todos los objetos espaciales que estn dentro de una
regin definida por un rango [Sam90a].
3. Consulta del vecino ms prximo. sta es una consulta espacial que busca, entre un
conjunto de objetos espaciales, el objeto espacial ms prximo a uno previamente dado.
Si generalizamos esta consulta, obtenemos los K objetos ms prximos al objeto
espacial consulta (los K vecinos ms prximos) [RKV95].
4. Join espacial. Este tipo de consulta tiene como entrada dos o ms conjuntos de objetos
espaciales y determina pares (o tuplas en el caso de tener ms de dos conjuntos) de
objetos espaciales que verifican una determinada propiedad espacial. Por ejemplo, el
join espacial que acta sobre dos conjuntos de objetos espaciales, determina todos los
pares de objetos espaciales que se solapan entre ellos [BKS93a].
Esta tesis est dedicada a investigar los distintos aspectos de una nueva consulta espacial
basada en la relacin de cercana, la consulta de los pares ms cercanos, que consiste en
devolver, dados dos conjuntos de objetos espaciales, los pares de objetos ms cercanos entre
s, donde cada elemento del par pertenece a un conjunto diferente.
Introduccin
3
En este captulo de introduccin se pretende ofrecer una visin global del entorno del
problema y las soluciones propuestas como aportacin principal de esta tesis, y se organiza
como sigue. En el primer apartado se enuncia la motivacin que ha guiado el planteamiento
de esta tesis y el mbito donde se ubica. A continuacin, planteamos los objetivos perseguidos
con este trabajo de investigacin. En tercer lugar enumeramos las contribuciones ms
representativas de esta tesis. Y por ltimo, se presenta el contenido de la misma de forma
resumida.

1.2 mbito y motivacin

Esta tesis se ubica en el contexto del proyecto TMR europeo CHOROCHRONOS
(ERBFMRXCT960056). CHOROCHRONOS (Espacio-Tiempo, en griego) fue una red de
investigacin europea para estudiar el diseo, implementacin y aplicacin de sistemas de
gestin de bases de datos espacio-temporales. Su duracin fue de aproximadamente 4 aos,
desde mediados de 1996 hasta mediados del 2000. Las universidades que integraron
CHOROCHRONOS fueron: (1) National Technical University of Athens (Greece), (2)
Aalborg University (Denmark), (3) FernUniversitaet Hagen (Germany), (4) University of
LAquila (Italy), (5) University of Manchester Institute of Science and Technology (U.K.),
(6) Politecnico di Milano (Italy), (7) Institut National de Recherche en Informatique et en
Automatique (France), (8) Aristotle University of Thessaloniki (Greece), (9) Technical
University of Vienna (Austria), y (10) Swiss Federal Institute of Technology (Switzerland).
Los objetivos principales de esta red eran los siguientes: (1) estudio de la ontologa, estructura
y representacin del espacio y del tiempo, (2) modelos y lenguajes para sistemas de gestin de
bases de datos espaciales y temporales, (3) desarrollo de interfaces de usuario grficas para
informacin espacio-temporal, (4) procesamiento de consulta en bases de datos espacio-
temporales, (5) estructuras de almacenamiento y tcnicas de indexacin para informacin
espacio-temporal, y (6) arquitectura de un sistema de bases de datos espacio-temporal.
Esta tesis se gest en el nodo CHOROCHRONOS de la Aristotle University of
Thessaloniki (Greece), dirigido por el Dr. Yannis Manolopoulos, especializado en tcnicas de
indexacin espacial y en el anlisis de estructuras de datos espaciales. A dicho nodo (Data
Enginnering Laboratory), me incorpor a principios de Septiembre de 1998 y mi estancia dur
10 meses, los cuales fueron muy productivos y sirvieron para fijar los objetivos de este trabajo
de investigacin. Posteriormente, he realizado estancias ms cortas (2, con duracin de un
mes cada una) para evaluar los avances en la investigacin en el entorno de esta tesis.
La creciente demanda de posibles consultas de muy diferente naturaleza en aplicaciones
que organizan los datos utilizando mtodos de acceso espaciales (R-tree) y el procesamiento
eficiente de las mismas, nos ha conducido a investigar en este campo. Los algoritmos branch-
and-bound son apropiados para obtener respuestas rpidas ante consultas espaciales sobre
estas estructuras de datos arbreas, ya que stos transforman los problemas en subproblemas
de tamao ms pequeo conforme descienden en el recorrido de los rboles y reducen el
espacio de bsqueda aplicando heursticas de poda. Al mismo tiempo, hemos indagado en
Captulo 1
4
tcnicas que optimizan estas consultas en base al nmero de operaciones de E/S y al tiempo
de respuesta, principalmente.
El join espacial y la consulta del vecino ms prximo son, sin duda alguna, las consultas
sobre mtodos de accesos espaciales ms estudiadas. La primera extrae de dos conjuntos de
objetos espaciales, los pares de objetos que satisfacen un determinado predicado espacial,
mientras que la segunda, a partir de un conjunto de objetos espaciales encuentra aquellos que
estn ms prximos a otro objeto espacial determinado. Ante preguntas del tipo: cules son
las 5 tiendas que estn ms cerca de un almacn cualquiera? o cules son las ciudades con
ms de 500000 habitantes que estn ms prximas a algn ro?, surge la consulta relacionada
con los pares ms cercanos basada en la relacin de cercana, y junto a ella la necesidad de
disear e implementar algoritmos que den respuesta de manera eficiente. Esta consulta es
como un join espacial en el sentido de que todos los pares de objetos son candidatos al
resultado final; y como una consulta del vecino ms prximo puesto que se utilizan
heursticas de poda basadas en distancias para reducir el espacio de bsqueda. Si partimos de
la base de que los objetos espaciales que intervienen en la consulta o sus aproximaciones
(MBRs) estn indexados en uno de los mtodos de acceso espacial ms conocido y de
eficiencia contrastada como es el R*-tree, entonces los algoritmos branch-and-bound son los
ms apropiados, ya que toman informacin sobre la optimalidad de soluciones parciales para
evitar considerar soluciones que pueden no ser ptimas, y por tanto reducir el espacio de
bsqueda notablemente.

1.3 Objetivos de la tesis

El conjunto de objetivos que han guiado el planteamiento de esta tesis, se resume bsicamente
en los siguientes puntos:
1. Revisin de las consultas espaciales ms conocidas. Diseo e implementacin de los
algoritmos que llevan a cabo dichas consultas sobre mtodos de acceso basados en
MBRs (R*-tree).
2. Definicin de la consulta del par ms cercano y su extensin a los K pares ms
cercanos. Definicin de funciones basadas en distancias entre pares de MBRs y
heursticas de poda para aplicarlas en algoritmos branch-and-bound [HoS78, Iba87,
BrB97] (reduccin del espacio de bsqueda) que den respuesta eficiente a dicha
consulta siguiendo diferentes estrategias de bsqueda.
3. Implementacin de algoritmos branch-and-bound no incrementales recursivos e
iterativos para la consulta del par ms cercano utilizando R*-tree como mtodo de
acceso espacial. Con el objetivo de minimizar el nmero de accesos a disco y tiempo de
respuesta, se implementan tcnicas de optimizacin utilizando las estructuras de datos
ms adecuadas.
Introduccin
5
4. Adaptacin de los algoritmos para la consulta del par ms cercano a extensiones del
mismo, como por ejemplo, los K pares ms cercanos, la Auto-consulta y la Semi-
consulta de los pares ms cercanos, la consulta de los K pares ms lejanos, etc.
5. Evaluacin de los algoritmos para obtener los pares ms cercanos y sus extensiones
aplicadas a datos de naturaleza espacial (puntos), fundamentalmente respecto al nmero
de accesos a disco y al tiempo de respuesta. Comparativa con la alternativa incremental
[HjS98].

1.4 Contribuciones

Considerando el creciente inters demostrado por un importante nmero de investigadores
hacia los algoritmos para el procesamiento de consultas sobre mtodos de acceso espaciales, y
muy especialmente en el join espacial, no resulta difcil observar que en este campo existe un
trabajo futuro interesante. En este sentido, la tesis que presentamos representa una aportacin
adicional en dicha rea, cuya particularidad ms significativa es la de conjugar las
caractersticas que nos ofrecen modernos mtodos de acceso espacial con tcnicas
algortmicas (branch-and-bound) para resolver consultas espaciales, en nuestro caso, la del par
ms cercano y sus extensiones [CMT
+
00a, CMT
+
00b].
Las contribuciones ms destacables en el rea del procesamiento de consultas espaciales
sobre R-trees, resultado de la investigacin llevada a cabo en este contexto, son las tres
siguientes: Por una lado, en esta tesis se describen resultados originales relacionados con el
procesamiento de consultas espaciales utilizando el R*-tree como mtodo de acceso.
Tambin, se presentan funciones basadas en distancias entre pares de MBRs y heursticas de
poda que, aplicadas en algoritmos branch-and-bound (recursivos e iterativos) para reducir el
espacio de bsqueda sobre estructuras de datos arbreas, hacen de la consulta del par ms
cercano sobre datos espaciales una consulta realmente eficiente [CMT
+
00b, CoS00, CVM01].
Por ltimo, se extienden estos algoritmos para cubrir otros tipos de consultas basadas en
distancias, relacionadas con el par ms cercano, no slo aplicables en el campo de las bases de
datos espaciales [CRV01].

1.5 Descripcin del contenido

Este apartado resume los contenidos que, captulo a captulo, el lector puede encontrar en el
interior de esta memoria.
En el captulo 2 se hace una revisin de los mtodos de acceso multidimensionales ms
conocidos. Despus se estudia el modelo de organizacin de ndices basados en MBRs en un
espacio de datos multidimensional, presentndose un conjunto de definiciones y propiedades
de los mismos. Una vez descrito este modelo de organizacin, se hace una breve revisin de
Captulo 1
6
los mtodos de acceso multidimensionales basados en MBRs ms conocidos, la familia de los
mtodos de indexacin R-trees k-dimensionales. Tambin, se definen formalmente las
consultas espaciales ms importantes. Finalmente, se realiza un estudio exhaustivo de los R*-
trees, que es el mtodo de indexacin espacial ms extendido y estudiado. Para ello, se
presenta al R-tree como mtodo de indexacin base de los R*-trees, se describen todos los
algoritmos que gestionan dinmicamente este mtodo de acceso, y se disean todos los
algoritmos para las consultas espaciales definidas previamente, utilizando este ndice espacial.
El captulo 3 se centra en la consulta base de esta tesis: la consulta del par ms cercano y
su extensin a los K pares ms cercanos. En primer lugar se establecen los conceptos
mtricos necesarios para presentar la consulta en cuestin. Despus se define dicha consulta y
se proponen algunas aplicaciones de la misma, fundamentalmente en el campo de las bases de
datos espaciales. A continuacin, se establece la relacin que existe entre la consulta del par
ms cercano, el join espacial y la consulta del vecino ms prximo. Por ltimo, se definen las
mtricas basadas en MBRs y teoremas que son la base para establecer heursticas de poda
para aplicarlas en algoritmos branch-and-bound (recursivos e iterativos) que den solucin a
esta consulta.
En el captulo 4 se presentan una serie de algoritmos para dar respuesta a la consulta del
par ms cercano, estando los dos conjuntos de objetos indexados por sendos R*-trees. Se
proponen varias aproximaciones en forma de algoritmos branch-and-bound, destacando la que
sigue un esquema de join en bucle anidado sobre ndices como variante recursiva (recorrido
en profundidad), y la que utiliza un montculo mnimo para almacenar todos los posibles
pares de MBRs organizados en base a la mnima distancia entre ellos como alternativa
iterativa (estrategia de bsqueda de primero el mejor). Para mejorar an ms estos algoritmos
branch-and-bound, se presentan tcnicas de optimizacin pare reducir el nmero de accesos a
disco y el tiempo de respuesta.
Las extensiones y casos de estudio presentados en este captulo 5, pretenden demostrar el
grado de operatividad que pueden proporcionar los algoritmos estudiados en el captulo 4.
Estas extensiones son las siguientes: (a) realizar la consulta del par ms cercano sobre R*-
trees con diferentes alturas, (2) poder llevar a cabo dicha consulta para el caso en que los
objetos espaciales no estn almacenados en los nodos hoja de los R*-trees, sino que en stos
estn los MBRs que los envuelven junto con punteros a registros con la representacin real de
los objetos espaciales que estn guardados en otro archivo externo, (3) obtener los K pares
ms cercanos, siendo esta extensin la ms interesante y de gran aplicacin, (4) encontrar
todos o los K pares ms cercanos que tienen una distancia en un rango dado a priori
[Dist_Min, Dist_Max], (5) encontrar el par ms lejano o los K pares ms lejanos de dos
conjuntos de objetos almacenados en R*-trees, y (6) realizar la Auto-consulta y la Semi-
consulta de los pares ms cercanos.
Los resultados experimentales desarrollados durante la preparacin de esta tesis se renen
en el captulo 6. En l, llevamos a cabo un conjunto de experimentos para las diferentes
versiones de los algoritmos branch-and-bound CPC y K-CPC, considerndose como
parmetros principales de evaluacin, el nmero de accesos a disco y el tiempo de respuesta.
Tambin se evalan las dos tcnicas propuestas para el tratamiento de R*-trees con diferentes
alturas y se estudia el efecto del porcentaje de solape entre las reas que cubren los conjuntos
de datos que intervienen en la consulta. Se considera el efecto de incluir un buffer de pginas
junto con una poltica de reemplazo LRU (Least Recently Used), ya que reduce
Introduccin
7
considerablemente la actividad de E/S de la consulta en cuestin. De igual forma, se
comparan nuestros algoritmos branch-and-bound no incrementales (recursivos e iterativos)
para K-CPC con los incrementales (iterativos). Por ltimo, se estudia el comportamiento de
adaptar nuestros algoritmos para realizar la Auto-CPC y Semi-CPC.
La tesis finaliza con el captulo 7, donde se resumen las conclusiones ms destacables y se
describen los trabajos a desarrollar en el futuro dentro de esta lnea de investigacin.


9


Captulo 2


MTODOS DE ACCESO
ESPACIALES BASADOS EN MBRs.
R*-TREE



2.1 Introduccin

Existe un gran nmero de aplicaciones que requieren un acceso rpido segn varias
propiedades de un conjunto de datos. Este acceso puede ser ineficiente o incluso imposible de
gestionar si dichos datos multidimensionales se organizan utilizando estructuras de datos de
clave nica (unidimensionales) como son los rboles binarios, los B-trees y los mtodos
hashing. Para solucionar este problema, muchas estructuras que soportan acceso
multidimensional han sido propuestas en los ltimos aos. De igual forma, dichas estructuras
de acceso han sido desarrolladas para satisfacer los requerimientos (gestin de grandes
volmenes de datos de manera eficiente y rpida) en importantes campos de aplicacin (GIS,
CAD, multimedia, etc.) a nivel interno en sistemas de bases de datos actuales. De todas ellas,
nos centraremos en las estructuras de datos arbreas multidimensionales basadas en MBRs y
balanceadas en altura que almacenan los datos en disco, los R-trees. Estos rboles se utilizan
para la organizacin dinmica de un conjunto de objetos k-dimensionales representados por
los mnimos rectngulos envolventes k-dimensionales.
En este captulo vamos a presentar los mtodos de acceso multidimensionales basados en
MBRs. En primer lugar, haremos una revisin de los mtodos de acceso multidimensionales
ms conocidos. Despus estudiaremos el modelo de organizacin de ndices basados en
MBRs en un espacio de datos multidimensional, presentndose un conjunto de definiciones y
propiedades de MBRs en dicho espacio. Una vez descrito este modelo de organizacin, se
har una revisin de los mtodos de acceso arbreos multidimensionales basados en MBRs
Captulo 2
10
ms conocidos, la familia de los mtodos de indexacin R-trees k-dimensionales. Tambin, se
definen las consultas espaciales ms significativas. La ltima parte de este captulo est
dedicada al estudio de los R*-trees [BKS
+
90], que es el mtodo de indexacin espacial ms
extendido y estudiado. Para ello, introducimos a los R-trees [Gut84] como mtodo de
indexacin base de los R*-trees, y todos los algoritmos necesarios para mantener este ndice
multidimensional. Adems, presentamos los algoritmos para el procesamiento de las consultas
espaciales ms representativas definidas anteriormente, utilizando el R*-tree como mtodo de
acceso espacial.

2.2 Mtodos de acceso multidimensionales. Una revisin

En los ltimos aos, aplicaciones cuyo uso ya es habitual, como los sistemas de informacin
geogrfica (GIS), diseo asistido por ordenador (CAD), aplicaciones multimedia, bases de
datos de imgenes y, ms recientemente, el tratamiento de almacenes de datos (Data
Warehousing) o de datos de naturaleza temporal estn exigiendo sistemas que sean capaces de
gestionar de manera adecuada no slo grandes volmenes de datos sino tambin datos que
incluyan una alta dimensionalidad.
Los mtodos de acceso unidimensionales, como el B-tree o sus variantes, o los
mecanismos de tipo hashing, se muestran incapaces de dar una respuesta eficiente a este tipo
de requerimientos. Las necesidades actuales exigen estructuras de almacenamiento que sean
capaces de responder eficientemente a consultas, por mltiples atributos, sin necesidad de que
haya una preferencia en el orden de los mismos, consultas en rango o consultas de
proximidad. Adems, estas estructuras deben adaptarse dinmicamente al crecimiento o
disminucin de la informacin de manera adecuada y ser capaces de gestionar grandes
volmenes de datos de alta dimensionalidad, obteniendo un rendimiento lo ms cercano
posible al del B
+
-tree [Com79].
En [GaG98, SPJ99] se resumen una serie de requerimientos que debera cumplir todo
mtodo de acceso, entre los que cabe destacar la simplicidad, independencia del orden de
entrada y distribucin de los datos, escalabilidad, soporte de un amplio rango de operaciones,
uso eficiente del espacio de almacenamiento, tiempo de acceso y respuesta razonable,
capacidad para el almacenamiento en memoria secundaria, acceso concurrente y mecanismos
de recuperacin, y fcil integracin en un sistema de base de datos tradicional con impacto
mnimo en el resto del sistema. Evidentemente, muchos de los mtodos propuestos cumplen
slo algunos de los requerimientos y es difcil que puedan ser implementados en sistemas
reales, pero la mayora han supuesto un paso ms en las investigaciones proponiendo ideas y
mecanismos que posteriormente han podido ser aplicados en la resolucin de otros problemas.
Todos los mtodos de acceso multidimensionales tienen en comn el considerar o bien
tuplas (registros), o bien objetos caracterizados en el espacio multidimensional, donde cada
atributo (campo) que se desee indexar se corresponde con una dimensin. Adems, la
estructura de datos se construye mediante divisiones recursivas de este espacio
multidimensional, hasta obtener subespacios (mutuamente disjuntos o no) con un nmero de
tuplas (u objetos) tal que permita poder almacenarlas en una pgina de datos.
Mtodos de acceso espaciales basados en MBRs. El R*-tree
11
Los diferentes mecanismos para realizar estas divisiones del espacio y la implementacin
de los mismos dan lugar a distintos mtodos de acceso multidimensionales. Dada la gran
cantidad de estructuras de acceso multidimensionales existentes, las vamos a clasificar por
grupos con caractersticas comunes y describiendo brevemente las ms representativas de
cada grupo.
La primera clasificacin que realizamos presenta como resultado dos grandes grupos: (1)
mtodos de acceso que representan las divisiones del espacio mediante una estructura que
debe mantenerse en memoria principal para obtener un mecanismo eficiente, y (2) mtodos de
acceso que paginan la estructura que representa la divisin del espacio, de tal manera que
puede almacenarse en memoria secundaria.

2.2.1 Mtodos de acceso multidimensionales basadas en memoria
principal

Las primeras estructuras multidimensionales que surgieron estn pensadas para almacenarse
en memoria principal. Obviamente, este requerimiento las hace inservibles en muchas
aplicaciones donde el volumen de datos hace necesario utilizar memoria secundaria. Sin
embargo, la importancia de estas estructuras radica en haber sido las primeras en considerar la
posibilidad de indexacin multidimensional y, de hecho, las ideas que sustentan han sido la
base para el desarrollo de casi todas las estructuras posteriores.
Una de las estructuras de datos ms representativas es el k-d-tree [Ben75], que es un
mtodo de acceso que divide el espacio multidimensional de manera sucesiva en partes cada
vez ms pequeas, de forma muy similar a como los rboles binarios dividen el espacio
unidimensional. Por ejemplo, en la Figura 2.1 se muestra un conjunto de puntos en el espacio
bidimensional y su representacin en un k-d-tree. Cada lnea corresponde a un nodo del rbol
cuya capacidad se ha establecido a uno. Cada valor del nodo del k-d-tree divide el espacio en
dos segn una determinada dimensin. La divisin se realiza fijando una dimensin en el
nodo raz (Y), siguiendo con otra dimensin (X) en los nodos del nivel siguiente, y as
sucesivamente, cambiando de dimensin de manera cclica.

(a) (b)
X
Y
(0, 0)
p1
p2
p3
p4
p5
p6
p1
p2
p3
p4
p5
p6
Y
X
Y
X
...

Figura 2.1 Ejemplo de un k-d-tree (orden de insercin: p1, p2, p3, p4, p5, p6).
Captulo 2
12
Otra estructura de datos muy conocida que pertenece a esta categora es el Quadtree
[FiB74], donde cada nodo del rbol est asociado a una regin cuadrada del espacio, por lo
que la divisin recursiva de dicho espacio se hace en base a cuadrantes de igual tamao.
Tambin debemos citar al BD-tree [OhS83], que presenta como novedad la identificacin de
regiones mediante secuencias de bits.

2.2.2 Mtodos de acceso basados en almacenamiento secundario

Los mtodos que se presentan en este apartado han sido diseados para poder almacenarse en
memoria secundaria, de forma que las estructuras de datos (archivos) que les dan soporte
estn paginadas. Inicialmente, distinguimos entre mtodos de acceso a puntos (MAP), que se
basan en considerar las tuplas como puntos en el espacio, y mtodos de acceso espacial
(MAE) que consideran no slo puntos sino objetos en su extensin espacial. Los mtodos de
acceso a puntos, sin embargo, como explican sus diseadores, pueden utilizarse tambin para
direccionar objetos espaciales realizando una transformacin, ya sea usando el centro del
objeto, los vrtices o alguna otra caracterstica. Entre todos los mtodos, independientemente
de que sean MAP o MAE, se pueden a su vez observar aspectos en comn y diferencias
generales que permiten de algn modo clasificarlos, principalmente respecto a las
caractersticas de las regiones a las que da lugar la divisin del espacio.
En la Tabla 2.1 se puede observar una clasificacin general de los mtodos de acceso
basados en almacenamiento secundario ms importantes.

Mtodos de Acceso a Puntos (MAP) Mtodos de Acceso Espaciales (MAE)
Hashing Jerrquicos Hbridos Baja Dimensionalidad Alta Dimensionalidad
Grid File
[NHS84]
k-d-B-tree
[Rob81]
Bang File [Fre87] R-tree [Gut84] TV-tree [LJF94]
Excell
[Tam82]
LSD-tree
[HSW89]
Buddy-tree
[SeK90]
R*-tree [BKS
+
90] X-tree [BKK96]
Two-Level
Grid File
[Hin85]
hB-tree [LoS90] P-tree [Jag90] SS-tree [WhJ96]
Twin Grid File
[HSW88]
Q-tree [Bar96] SR-tree [KaS97]
BV-tree [Fre95] Pyramid-tree [BBK98]
IQ-tree [BBJ
+
00]
A-tree [SYU
+
00]
Tabla 2.1 Clasificacin general de los mtodos de acceso basados en almacenamiento
secundario.



Mtodos de acceso espaciales basados en MBRs. El R*-tree
13
2.2.2.1 Mtodos de acceso a puntos

Algunos de los mtodos de acceso que se presentan estn basados en la utilizacin de
funciones de dispersin de registros (hashing) y otros estn ms prximos a estructuras
arbreas (jerrquicas). Tambin hay otros mtodos que toman ideas de ambos mecanismos
(hbridos).
Mtodos de acceso basados en hashing
Los mtodos de este tipo no han resultado muy adecuados a las necesidades
multidimensionales, principalmente porque todos ellos sufren, en mayor o menor grado, el
crecimiento superlineal del denominado directorio y las dificultades para paginarlo.
El mtodo ms conocido es el Grid File [NHS84], que representa la divisin del espacio
mediante una rejilla de k dimensiones, cuyas celdas no siempre tienen el mismo tamao. Esta
estructura est formada por las pginas de datos (almacenadas en disco), el directorio
(compuesto por las celdas k-dimensionales, permitiendo relacionar las celdas con las pginas
de datos), y las escalas (mantienen informacin de las divisiones que se han realizado del
espacio en cada dimensin). Mientras las pginas de datos y el directorio se mantienen en
memoria secundaria, las escalas deberan estar en memoria principal para garantizar un
rendimiento ptimo sobre consultas con varias claves de bsquedas.
Las variantes del Grid File (Excell [Tam82], Two-level Grid File [Hin85], y Twin Grid
File [HSW88]) pretenden solucionar los problemas planteados por esta estructura de acceso,
pero no lo consiguen totalmente o incluso provocan otros nuevos.
Mtodos de acceso jerrquicos
La mayora de estos mtodos de acceso estn basados en el k-d-tree [Ben75]. Su principal
caracterstica es que su estructura est representada por un rbol, sea ste binario o no. stos
organizan los puntos en una serie de regiones. Generalmente cada regin corresponde a una
pgina de datos que est almacenada en disco como una hoja del rbol. Los nodos internos del
rbol permiten guiar los procesos de bsqueda de arriba hacia abajo en la estructura.
Las operaciones de actualizacin del rbol, en general, se realizan de manera similar a
como se hacen en un B-tree [BaM72]. Por ejemplo, en la Figura 2.2 tenemos un B-tree, en el
que todos los valores de bsqueda aparecen slo una vez, dividiendo el espacio
unidimensional en varias partes segn el orden del rbol. Tanto la insercin como el borrado
requieren primero un proceso de bsqueda en el rbol hasta llegar al nivel ms bajo. Si el
elemento a insertar no cabe en la pgina correspondiente, se proceder a la divisin, lo que
hace que haya que modificar la informacin en el nivel inmediatamente superior, que tambin
puede desbordarse y as el proceso de divisin puede propagarse hacia arriba en el rbol.
Captulo 2
14

5 8
1 3 6 7 9 12

Figura 2.2 Ejemplo de un B-tree (orden de insercin: 8, 5, 1, 7, 3, 12, 9, 8).
El mecanismo de divisin de las pginas de ndice y los problemas que pueden producirse
derivados del mismo es lo que distingue bsicamente a los distintos mtodos. En este sentido,
hB-tree [LoB90] soluciona los problemas pendientes del K-D-B-tree [Rob81] y LSD-tree
[HSW89], proponiendo un mecanismo de divisin ms sofisticado. El Q-tree [Bar96], usando
las ideas bsicas del hB-tree, consigue una estructura ms homognea aunque no puede
garantizar una ocupacin mnima de las pginas en todas las situaciones. Una estructura
ligeramente diferente es el BV-tree [Fre95], que no es realmente un mtodo de acceso
concreto, sino que representa un intento de generalizar las caractersticas del B-tree al caso
multidimensional, proponiendo una serie de conceptos que pueden ser aplicados a otros
mtodos de acceso multidimensionales.
Mtodos de acceso hbridos
Presentan caractersticas propias de mtodos basados en hashing pero a la vez utilizan una
estructura arbrea como base para la representacin de la informacin. El ms representativo
es el Bang File [Fre87]. Este mtodo realiza la divisin del espacio en intervalos regulares de
la misma forma que un Grid File, pero representa el directorio mediante una estructura
arbrea balanceada. En realidad, la filosofa de divisin y representacin de regiones es muy
similar a la del BD-tree [OhS83].
El Buddy-tree [SeK90] es un esquema basado en hashing dinmico con un directorio
estructurado en forma de rbol. El rbol se construye por insercin consecutiva de elementos
en l, dividiendo recursivamente el espacio en dos partes de igual tamao con hiperplanos en
la misma orientacin.

2.2.2.2 Mtodos de acceso espaciales

La mayora de los mtodos tradicionales de este tipo no fueron ideados para ser usados con
ms de 3 dimensiones y slo recientemente han surgido estructuras pensadas para una alta
dimensionalidad. Por ello, los mtodos de acceso espaciales van a ser aquellos mtodos de
acceso diseados principalmente para almacenar objetos geomtricos.
La caracterstica comn que presentan estos mtodos de acceso es que agrupan los objetos
en regiones minimales, es decir, ajustadas a los objetos. Ahora bien, las caractersticas de
Mtodos de acceso espaciales basados en MBRs. El R*-tree
15
estas regiones difieren de unos mtodos a otros, principalmente en lo que se refiere a su forma
y a la relacin que mantienen las que pertenecen al mismo nivel. Este ltimo criterio nos
permite clasificar los mtodos en cuatro grupos: (1) aquellos que transforman los objetos en
una representacin diferente (mapendolos en un punto de dimensin mayor o
transformndolos en un conjunto de intervalos unidimensionales segn curvas de llenado del
espacio); (2) los que representan el espacio mediante regiones solapadas; (3) los que lo
representan mediante regiones disjuntas; y (4) los que lo representan en mltiples capas, que
en realidad es una extensin del primero.
La estructura pionera es el R-tree [Gut84] que ha servido de base a otros muchos mtodos
que surgieron al tratar de mejorar algunos aspectos del mismo. sta es una estructura arbrea
multidimensional balanceada en altura que representa una jerarqua de regiones rectangulares
minimales (MBRs). Es decir, los R-trees son estructuras de datos arbreas balanceadas en
altura muy parecidas a los B-trees; sin embargo, en lugar de rangos de valores se asocian
MBRs con cada nodo del rbol. Cada nodo del R-tree corresponde a una pgina de datos. En
los nodos hoja estn almacenados un identificador para cada objeto y el MBR que lo contiene,
y los nodos internos representan una sucesin de regiones rectangulares minimales, cada una
de las cuales controla un nodo en el nivel inferior. Las regiones del mismo nivel pueden
solaparse y su unin no necesariamente cubre el universo completo. El rbol est balanceado
en altura y se garantiza una ocupacin mnima de los nodos. En aos posteriores han surgido
muchas variantes de esta estructura y se le ha dotado de concurrencia mediante los mismos
mecanismos usados en los B-trees [BaM72].
Todos los mtodos que manejan regiones solapadas, R-tree, R*-tree [BKS
+
90], P-tree
[Jag90], etc., tienen el problema de que una bsqueda exacta puede tener que seguir varios
caminos, aunque en algunas estructuras como el R*-tree, el solape ha disminuido mucho pero
el proceso de insercin resulta ms complejo y costoso. Los mtodos que manejan regiones
disjuntas, R
+
-tree [SRF87] y Cell-tree [Gn89], tienen que resolver el problema de la
redundancia en el almacenamiento de objetos y de evitar el solape cuando algunas regiones
deben ser expandidas durante el proceso de insercin. En general, todos los mtodos de
acceso de este tipo, excepto el Cell-tree, manejan regiones minimales por lo que nuevas
inserciones de objetos pueden producir actualizaciones en los lmites de las regiones, an
cuando no haya desbordamiento de pginas.
En los ltimos aos han surgido mtodos de acceso basados en las ideas del R-tree pero
pensados para grandes dimensiones. Tal es el caso del TV-tree [LJF94], X-tree [BKK96], SS-
tree [WhJ96], SR-tree [KaS97], Pyramid-tree [BBK98], etc. Adems, algunos presentan como
novedad la forma de las regiones, que ya no es rectangular: el SS-tree maneja regiones
esfricas, el SR-tree utiliza esferas y MBRs, y el Pyramid-tree gestiona pirmides. Muy
recientemente se han presentado trabajos como el IQ-tree [BBJ
+
00] y el A-tree [SYU
+
00]. El
IQ-tree es un ndice comprimido con una estructura de datos a tres niveles. El primer nivel
almacena la representacin exacta de los MBRs; el segundo nivel lo denominan pginas de
datos comprimidas, que contienen puntos de forma comprimida; y el tercer nivel guarda la
representacin exacta de los datos. El A-tree (Approximation tree) es un ndice arbreo para
la bsqueda por cercana en espacios de datos multidimensionales y que utiliza para la
representacin de los MBRs y de los objetos, una aproximacin relativa de sus MBRs
ancestros denominada VBR (Virtual Bounding Rectangle).

Captulo 2
16
2.3 Modelo de organizacin de ndices basados en MBRs
en el espacio de datos k-dimensional

Para definir el modelo de organizacin de ndices basados en MBRs en el espacio de datos k-
dimensional debemos introducir una serie de conceptos bsicos tomados fundamentalmente
de [Pol96, Bec92, ElN97], aunque tambin se han utilizado para ello [ACP
+
99, DeP99,
GUW99, MTT99, One94, Ram97, RSV01, SKS98, ZCF
+
97].
Definicin. Espacio n-dimensional de datos.
Se define el espacio n-dimensional de datos (espacio multidimensional) D
(n)
como:
( ) { }
i i n i i n
n
D v v D D D D

: ...
1 2 1
) (

donde cada dominio D
i
est formado por un conjunto de valores, sobre los que est definida
una relacin de orden
i
, que salvo indicacin explcita, se denotar como para cualquier
1in. Adems, dichos dominios no tienen que ser necesariamente distintos.
Definicin. Tupla n-dimensional.
Se define una tupla n-dimensional t en D
(n)
, como un conjunto finito de n valores de la forma.
t = (v
1
, v
2
, ..., v
n
) = (v
i
)
1 i n
D
(n)
: donde v
i
D
i

Segn [ElN97], las bases de datos desde un punto de vista fsico estn organizadas en
archivos de registros los cuales se almacenan fsicamente en la computadora utilizando
medios de almacenamiento no voltil, como puede ser un disco duro. Las aplicaciones de base
de datos slo requieren una pequea parte de la informacin en un momento determinado, con
el objetivo de procesarla. Siempre que se requiera una parte de los datos, habr que localizarla
en disco, copiarla en memoria principal para procesarla y por ltimo escribirla en disco si la
informacin ha sido modificada. Los datos almacenados en el disco se organizan en archivos
de registros, los cuales a su vez pueden estar paginados o no.
Para organizar los datos vamos a suponer que las tuplas n-dimensionales (registros) estn
almacenadas en un archivo n-dimensional de datos, F. Los registros de F estn distribuidos
segn un ndice multidimensional, I, no denso (tiene una entrada por cada pgina de datos del
archivo de datos, no una por cada registro) que est asociado a dicho archivo n-dimensional
de datos.
Definicin. Archivo n-dimensional de datos.
Un archivo n-dimensional de datos es un par F = ({A
1
, A
2
, ..., A
n
}, {(v
i
)
1 i n
D
(n)
}), donde
{(v
i
)
1 i n
D
(n)
} son tuplas n-dimensionales y {A
1
, A
2
, ..., A
n
} son atributos (identificadores
de cada componente de la tupla n-dimensional) asociados a cada dominio.
Es decir, un archivo n-dimensional de datos es una coleccin de tuplas n-dimensionales,
caracterizadas por un conjunto de n atributos.


Mtodos de acceso espaciales basados en MBRs. El R*-tree
17
Definicin. Conjunto de atributos clave en un archivo n-dimensional de datos.
Dado un archivo n-dimensional de datos F = ({A
1
, A
2
, ..., A
n
}, {(v
i
)
1 i n
D
(n)
}), se dice que
un subconjunto de atributos {A
1
, A
2
, ..., A
k
} (k n) es clave de F, si dadas dos tuplas t = (v
1
,
v
2
, ..., v
n
) y t = (v
1
, v
2
, ..., v
n
) F y t t, entonces existe un i (1 i k) tal que v
i
v
i
.
Es decir, un subconjunto de atributos {A
1
, A
2
, ..., A
k
} de un archivo n-dimensional de
datos F es clave, si satisface la propiedad de identificar de forma nica a cada una de las
tuplas de dicho archivo.
De forma general, podemos decir que el conjunto de n atributos {A
1
, A
2
, ..., A
n
} que
caracteriza a un archivo n-dimensional de datos se puede dividir en dos subconjuntos C y C,
donde C = {A
1
, A
2
, ..., A
k
} es el conjunto de atributos que son clave para la organizacin del
archivo n-dimensional, y C contiene los atributos que no son clave para la organizacin del
archivo. Es decir, una tupla n-dimensional de un archivo n-dimensional de datos est
caracterizada por los atributos {A
1
, A
2
, ..., A
n
}, de los cuales C son atributos clave y los
restantes C son atributos no clave (n = C + C).
Basndonos en el modelo de representacin de informacin multidimensional [Pol96]
podemos definir una estructura de datos que nos permita realizar una organizacin de dicho
espacio sobre k atributos bajo determinadas condiciones, dando lugar a lo que denominaremos
ndice arbreo k-dimensional.
Definicin. ndice arbreo k-dimensional balanceado en altura.
Un ndice arbreo k-dimensional balanceado en altura en D
(k)
es, un conjunto de nodos
formando un rbol como estructura de datos, y un conjunto de operaciones que gestionan
dicha estructura bajo determinadas propiedades, haciendo que el rbol est balanceado en
altura (las hojas, como nodos terminales, siempre residen en el mismo nivel). A su vez, cada
nodo del rbol es un conjunto de elementos de la forma <K
i
, P
i
>, siendo K
i
un conjunto de
tuplas k-dimensionales y P
i
un puntero (nmero), que denominaremos entradas del nodo.
Dicho ndice arbreo k-dimensional puede estar almacenado en disco utilizando un archivo
para organizar los nodos. Este archivo contiene registros de longitud fija que equivalen a los
nodos del rbol, que a su vez contienen un nmero finito de entradas de la forma <K
i
, P
i
>. K
i

es una tupla k-dimensional y P
i
, es un puntero (posicin absoluta de un registro en un archivo)
que puede apuntar a un registro del ndice arbreo k-dimensional o a un registro del archivo k-
dimensional de datos siguiendo alguna propiedad especfica. El desarrollo de estos
procedimientos est enfocado a la construccin del ndice mediante la organizacin de los
datos multidimensionales en el espacio k-dimensional, obteniendo subconjuntos en
subespacios (disjuntos o no) con un nmero de nodos que puedan ser almacenados en el
archivo. Los diferentes mecanismos para realizar estas organizaciones del espacio y la
implementacin de los mismos dan lugar a distintos tipos de ndices arbreos k-dimensionales
balanceados en altura.
Un ndice arbreo k-dimensional, como estructura de datos arbrea, estar compuesta por
nodos (registros). Cada nodo del ndice, a excepcin de un nodo especial denominado raz,
tiene un nodo padre y varios (cero o ms) nodos hijo. Los nodos que no tienen hijos se les
denomina nodos hoja, y los nodos que no son hoja se conocen como nodos internos. El nivel
de un nodo es siempre el nivel de su padre menos 1, y el de los nodos hoja es 0. Un subrbol
comenzando en un nodo consiste en ese nodo y en todos sus descendientes.
Captulo 2
18
Definicin. Nodos hoja y nodos internos de un ndice arbreo k-dimensional.
Un nodo hoja, de un ndice arbreo k-dimensional es cualquier nodo tal que: Los punteros
(P
i
) que son nulos, indican que no tiene nodos hijos del rbol. Y los punteros (P
i
) que no son
nulos, son punteros al archivo k-dimensional de datos.
Un nodo interno, de un ndice arbreo k-dimensional es todo nodo del ndice que no sea un
nodo hoja.
Definicin. Orden y grado de un nodo en un ndice arbreo k-dimensional.
Llamaremos orden de un nodo N en un ndice arbreo k-dimensional y se denotar por (m,
M), al nmero mnimo (m) y mximo (M), respectivamente, de pares de la forma <K
i
, P
i
>
que pueden almacenarse en dicho nodo.
Llamaremos grado de un nodo N en un ndice arbreo k-dimensional y se representa por
grado(N), al nmero de hijos no nulos que posee. Para conocer el valor del grado de un nodo
N, y sabiendo que su valor de entradas (pares de la forma <K
i
, P
i
>) mnimo es m, el mximo
es M, y est ubicado en el nivel l (l > 0). Entonces m
l
es una cota inferior y M
l
es una cota
superior para el grado de N (m
l
grado(N)M
l
).
De las definiciones anteriores, podemos deducir que el nmero de nodos, Num_Nodos, de
un ndice arbreo k-dimensional balanceado en altura de orden (m, M) y de altura h (nivel del
nodo raz ms uno) viene dado por la siguiente expresin.


1
0
1
0
_
h
l
l
h
l
l
M Nodos Num m
Una vez recordado brevemente el modelo de representacin de informacin
multidimensional y definido de forma general un ndice arbreo k-dimensional balanceado en
altura, vamos a destacar los aspectos ms importantes del modelo de representacin de MBRs
k-dimensionales sobre el espacio multidimensional de datos junto con la definicin de ndice
arbreo k-dimensional balanceado en altura y basado en MBRs k-dimensionales.
Definicin. Segmento o intervalo en el espacio de datos n-dimensional.
Dado un espacio n-dimensional D
(n)
, y una relacin de orden
i
definida sobre cada uno de
sus dominios D
i
. Definimos un intervalo o segmento en la dimensin i de D
(n)
como:
[ ] { }
i i i i i i i i
u v l D v u l I : ,
Definicin. n-rectngulo cerrado y limitado por un conjunto de intervalos en el espacio n-
dimensional.
Definimos un rectngulo n-dimensional o n-rectngulo, n_R, delimitado por un conjunto de
intervalos I = {[l
1
, u
1
], [l
2
, u
2
], ..., [l
n
, u
n
]} como una regin de D
(n)
en la que todas sus
coordenadas estn acotadas por un intervalo [l
i
, u
i
] sobre la dimensin i. Es decir, n_R es de
la forma:
( )
( )
{ }
i i i i i
n
n i i
D v u v l D v R n

, : _
1

Definicin. n-rectngulo cerrado y limitado por dos puntos (P
1
y P
2
) en el espacio n-
dimensional.
Sean los puntos n-dimensionales P
1
= (p
i
1
)
1 i n
y P
2
= (p
i
2
)
1 i n
D
(n)
, tal que p
i
1
p
i
2
,
llamaremos n-rectngulo cerrado y limitado por los puntos P
1
y P
2
, y cuyas caras son
Mtodos de acceso espaciales basados en MBRs. El R*-tree
19
paralelas a los ejes de coordenadas en cada dimensin, al conjunto de tuplas caracterizado
por la siguiente expresin:
( )
( )
{ }
i i i i i
n
n i i
P P
D v p v p D v R n

, : _
2 1
1
,
2 1

En la Figura 2.3 podemos ver n-rectngulos definidos por dos puntos para una, dos y tres
dimensiones, donde sus caras son paralelas a los ejes de coordenadas. Por ejemplo, en el
espacio de cuatro dimensiones, D
(4)
. 4_R
A,B
con A = (3, 6, 0, 5) y B = (9, 12, 3, 7); representa
el conjunto de tuplas de la forma t = (v
1
, v
2
, v
3
, v
4
) tales que, 3 v
1
9, 6 v
2
12, 0 v
3
3
y 5 v
4
7.

(a) (b) (c)

Figura 2.3 Ejemplo en una, dos y tres dimensiones de un n-rectngulo definido por dos
puntos.
Definicin. MBR (Minimum Bounding Rectangle) n-dimensional. Mnimo n-rectngulo que
envuelve a un conjunto T de tuplas n-dimensionales.
Dado un conjunto finito de tuplas n-dimensionales T = {t
1
, t
2
, ..., t
m
} : t
i
D
(n)
. ste estar
contenido en un n-rectngulo cerrado definido por los puntos P
T
min
y P
T
max
, y con sus caras
paralelas a los ejes de coordenadas en cada dimensin, que denominaremos cubrimiento
mnimo, envolvente mnimo, n-rectngulo minimal de T, o de manera abreviada MBR n-
dimensional.
( )
( )
{ }
i i i i i
n
n i i
P P
D v p v p D v R n
T T


, : _
max min
1 ,
max min
tal que,
( )
( )
( )

'





i
j
m j
i
n
n i i T
t p D p P
1
min
1
min min
min :
( )
( )
( )

'





i
j
m j
i
n
n i i T
t p D p P
1
max
1
max max
max :
A P
T
min
y P
T
max
se les denomina cubrimiento inferior y superior de T, respectivamente. Y
i

representa la proyeccin en la i-sima dimensin.
Debemos indicar que las caras de un MBR n-dimensional son MBRs de una dimensin
menor (MBRs (n 1)-dimensionales). Por ejemplo, en el espacio tridimensional (n = 3), el
MBR 3-dimensional que cubre al conjunto de tuplas T = {(3, 7, 2), (2, 0, 9), (5, 10, 15), (4, 9,
25)} es 3_R
P
T
min
,P
T
max
con P
T
min
= (2, 0, 2) y P
T
max
= (5, 10, 25). Adems, este MBR 3-
dimensional consta de 6 caras que son MBRs 2-dimensionales.
Basndonos en el modelo de representacin de MBR n-dimensionales sobre el espacio
multidimensional de datos, y extendiendo la definicin de ndice arbreo k-dimensional
Captulo 2
20
balanceado en altura, vamos a introducir el concepto de ndice arbreo k-dimensional
balanceado en altura y basado en MBRs k-dimensionales (R-tree k-dimensional), donde el
espacio multidimensional definido sobre k atributos se orgqniza en base a MBRs k-
dimensionales siguiendo determinados criterios.
Definicin. R-tree k-dimensional.
Definimos un R-tree k-dimensional como un ndice arbreo k-dimensional balanceado en
altura que verifica las siguientes propiedades:
Cada nodo hoja contiene entradas de la forma <K
i
, P
i
>, tal que K
i
es el MBR k-
dimensional que cubre un conjunto de tuplas k-dimensionales T, almacenado en un
archivo k-dimensional de datos. Y P
i
es un puntero a algunas de esas tuplas k-
dimensionales que forman el conjunto T. P
i
puede ser nulo, entonces las tuplas
almacenadas en K
i
representan informacin de utilidad para el usuario.
Cada nodo interno contiene entradas de la forma <K
i
, P
i
>, donde P
i
es un puntero a
un nodo hijo y K
i
es el MBR k-dimensional que cubre los MBRs k-dimensionales
contenidos en dicho nodo hijo.
Un R-tree k-dimensional de orden (m, M) tiene la propiedad de que cada nodo,
excepto posiblemente la raz, contiene entre m y M entradas, donde 2 m M/2. M es
el mximo nmero de entradas que puede tener cada nodo (capacidad mxima del
nodo). Por otro lado, m es un parmetro que especifica el mnimo nmero de entradas
en un nodo. El R-tree k-dimensional garantiza que la utilizacin del almacenamiento es
al menos m/M [Gut84], y que la altura del rbol crece de forma logartmica en funcin
del nmero de objetos caracterizados por tuplas k-dimensionales a indexar. Adems,
cada nodo del ndice se corresponde con una pgina del archivo en disco.
Las hojas siempre residen en el mismo nivel, es decir, el R-tree k-dimensional est
balanceado en altura. La altura de un R-tree k-dimensional es como mximo log
m
(N)
si se indexan N objetos caracterizados por tuplas k-dimensionales y m es el nmero
mnimo de entradas que puede haber en un nodo de dicho ndice.
El nodo raz contiene al menos dos entradas, si ste no es una hoja.
Debemos destacar tambin que el R-tree k-dimensional es un mtodo de indexacin
multidimensional completamente dinmico, en el que inserciones y borrados pueden llevarse
a cabo junto con consultas sin necesidad de realizar una reorganizacin de la informacin k-
dimensional a nivel global.

2.4 La familia de los R-trees k-dimensionales como mtodo
de acceso espacial basado en MBRs

Los R-trees [Gut84] son estructuras de datos arbreas multidimensionales basadas en MBRs,
y balanceadas en altura. stas se utilizan para la organizacin dinmica de un conjunto de
objetos k-dimensionales representados por sus MBRs k-dimensionales.
Como hemos mencionado anteriormente, los mtodos de acceso diseados para almacenar
objetos geomtricos caracterizados por su mnima envolvente se les denomina mtodos de
Mtodos de acceso espaciales basados en MBRs. El R*-tree
21
acceso espaciales (MAE). Un punto es un caso particular de objeto geomtrico y puede ser
gestionado por estos ndices, aunque mtodos de acceso a puntos (MAP) tambin pueden
utilizarse para almacenar objetos geomtricos aplicando tcnicas concretas [Bec92]. La
mayora de los MAE han sido diseados exclusivamente para la gestin de objetos espaciales
(puntos, lneas, regiones, polgonos, etc.). Por ello, es conveniente destacar las propiedades
bsicas de los datos espaciales segn [GaG98]:
1. Los datos espaciales tienen una estructura compleja. Un objeto espacial puede estar
compuesto por un nico punto o por varios miles de polgonos, distribuidos
arbitrariamente en el espacio.
2. Los datos espaciales son a menudo dinmicos. Operaciones de actualizacin, insercin
y borrado se llevan a cabo sobre los MAE utilizados en este contexto para soportar un
comportamiento dinmico sin deteriorar el tiempo de procesamiento.
3. No hay definida un lgebra estndar sobre datos espaciales, aunque se han hecho
varias propuestas entre las que podemos citar [Gt89, ScV89, GS93]. Esto quiere decir
que no existe un conjunto de operadores espaciales base estandarizado. El conjunto de
operadores espaciales depende en gran medida del dominio de aplicacin, aunque
algunos operadores son ms comunes que otros, como por ejemplo el operador de
solape.
4. Muchos operadores espaciales no son cerrados, ya que cuando actan sobre objetos
espaciales del mismo tipo, el objeto u objetos resultante pede ser de un tipo diferente al
de los objetos que intervienen en la operacin. Por ejemplo, el solape entre dos
polgonos (una o ms veces de forma consecutiva) puede devolver un nmero de puntos
aislados, aristas separadas, o polgonos disjuntos.
5. Aunque el coste computacional vara entre operadores espaciales, dichos operadores
son ms costosos de llevar a cabo que los operadores relacionales estndares.
Segn [Gt94], un sistema de base de datos espacial es un sistema de base de datos que
ofrece tipos de datos espaciales en su modelo de datos y un lenguaje de consulta,
suministrando indexacin espacial y algoritmos eficientes para el procesamiento de consultas
espaciales. De lo cual se deduce la gran importancia que tienen los mtodos de acceso
espaciales (MAE) como mecanismo de indexacin dentro de un sistema de base de datos
espacial.
Respecto al R-tree aplicado a sistemas de bases de datos espaciales, debemos considerar
que cada objeto espacial est limitado por el MBR que lo cubre. Cada nodo de un R-tree
corresponde al MBR que limita a sus hijos. Las hojas del rbol contienen punteros a los
objetos de la base de datos espacial, en lugar de punteros a nodos hijos, como les ocurre a los
nodos internos. Si los punteros de las hojas son nulos, los MBRs asociados representan
informacin espacial de utilidad para el usuario.
Cuando tenemos un objeto espacial O en el espacio bidimensional, el rectngulo ms
pequeo que cubre a O y cuyos lados son paralelos a los ejes de coordenadas en dicho espacio
(X, Y), puede determinarse con gran facilidad. Dicho rectngulo puede representarse por dos
puntos, uno de ellos en la esquina inferior izquierda que est definido por (x
min
, y
min
), y el otro
Captulo 2
22
es el punto situado en la esquina superior derecha y definido por (x
max
, y
max
). Entonces x
min
es
la coordenada X ms pequea posible de todos los puntos de O e y
min
es de igual forma la
coordenada Y ms pequea posible de todos los puntos de O. De forma similar se define x
max

como la coordenada X ms grande posible de todos los puntos de O e y
max
la coordenada Y
ms grande posible de todos los puntos de O. A este rectngulo se le denomina mnimo
rectngulo que envuelve o cubre al objeto espacial O, o de manera abreviada MBR. La
siguiente figura ilustra este concepto.

(x
min
, y
min
)
(x
max
, y
max
)
(x
min
, y
min
)
(x
max
, y
max
)
(a) X (c) X X
Y Y Y
(0, 0) (0, 0) (0, 0)
(b)
*

Figura 2.4 MBRs de uno o ms objetos.
La Figura 2.4.a ilustra el MBR que cubre un objeto regular. En la Figura 2.4.b podemos
comprobar que dos MBRs cubriendo dos objetos de forma separada pueden solaparse entre
ellos sin solaparse los objetos que cubren, es decir MBR(O
1
) MBR(O
2
) , siendo O
1

O
2
= . En la Figura 2.4.c aparece la extensin de MBR para cubrir a varios objetos. Por
ltimo, el concepto de MBR descrito para dos dimensiones (k = 2), puede extenderse
fcilmente para cualquier dimensin k 2.
La versin original del R-tree [Gut84] ha inspirado a muchos investigadores para realizar
mejoras sobre el mismo, con el objetivo de obtener mtodos de acceso espaciales basados en
el R-tree y mejorar su rendimiento. Una tcnica de empaquetado (packing) se propone en
[RoL85] para minimizar el solape entre diferentes nodos en el R-tree para datos estticos. La
idea para llevar a cabo esta tcnica es ordenar los MBRs de forma ascendente segn el valor
de su coordenada x
min
, examinar la lista de MBRs ordenada y llenar cada nodo hasta su
capacidad mxima aplicando criterios del vecino ms prximo. En [KaF93] se estudia una
tcnica que mejora el mtodo de empaquetado anterior y est basada en la curva de Hilbert,
debido a que la idea principal es ordenar los MBRs en base al valor Hilbert de sus centros.
Ms recientemente, en [LEL97] se muestra un mtodo sencillo y eficiente para llevar a cabo
el mismo objetivo (empaquetado de MBRs para generar un R-tree en que los datos no
cambian con el tiempo y son conocidos a priori) en la que considera el rea y el permetro de
los MBRs, junto con tcnicas de buffering para minimizar el nmero de accesos a disco,
comparndolo con las dos tcnicas anteriores.
Otro mtodo de indexacin basado en MBRs es el R
+
-tree [SRF87], cuya idea principal
est fundamentada en el K-D-B-Tree [Rob81]. El objetivo del R
+
-tree es evitar el solape
(overlap) entre los MBRs en nodos internos del mismo nivel. Es decir, todos los MBRs en un
mismo nivel (en niveles diferentes a las hojas) no se solapan. En el rbol resultante pueden
existir varios caminos para llegar a un determinado MBR empezando a partir de la raz. Todas
estas restricciones nos pueden conducir a un incremento en la altura del rbol que depende del
Mtodos de acceso espaciales basados en MBRs. El R*-tree
23
grado de solape que exista en el conjunto original de objetos a indexar. No obstante, el tiempo
necesario para la recuperacin de informacin es ms rpido debido a que si se toma un
camino, ste lleva con toda seguridad al objeto requerido sin necesidad de retroceder en el
proceso de bsqueda. Debido a que el R
+
-tree se puede considerar como una extensin del K-
D-B-Tree, ste no garantiza siempre un rendimiento ptimo en el llenado de nodos del rbol.
Pueden existir pginas que no se llenen a la mitad de su capacidad sin la utilizacin de
complicados algoritmos de insercin y borrado de objetos espaciales. Sin embargo, los
resultados experimentales propuestos en [SRF87] revelan un comportamiento interesante
comparado con el R-tree convencional. En [SRF87], los autores sugirieron que el rendimiento
del R
+
-tree puede mejorarse utilizando una minuciosa eleccin de lneas de divisin junto con
una cuidadosa agrupacin inicial de los MBRs a nivel de hojas. Esta ltima mejora puede
llevarse a cabo utilizando heursticas muy parecidas a las utilizadas para construir un R-tree
empaquetado (packed R-tree), como se hizo en [RoL85].
El R*-tree [BKS
+
90] es un mtodo de indexacin multidimensional derivado del R-tree y
difiere de este ltimo en la forma de dividir y combinar nodos en el proceso de insercin de
objetos. La principal idea es el concepto de reinsercin forzada, donde se trata de aplazar la
divisin de un nodo cuando ste se desborda (overflow). En concreto, cuando un nodo se
desborda (supera su capacidad mxima, M), algunas de sus entradas son cuidadosamente
escogidas siguiendo determinados criterios, extradas del nodo desbordado y reinsertadas en
el rbol, con el objetivo de obtener un R-tree mejor estructurado (menos solape entre MBRs
en un mismo nivel). De manera resumida indicamos que el R*-tree difiere del R-tree en que
utiliza unos algoritmos de insercin de objetos espaciales con tcnicas ms sofisticadas que
intentan minimizar el solape entre MBRs en un mismo nivel del rbol y su permetro total.
Cuando un nodo N de un R-tree se desborda, en lugar de dividir inmediatamente N, el
algoritmo de insercin del R*-tree primero trata de ver si alguna de las entradas de N podra
ser ubicada mejor en otro nodo. Esto se lleva a cabo mediante un proceso de reinsercin de
una fraccin fija de las entradas de N. Este proceso incrementa el tiempo en la construccin
del ndice, pero con un menor grado de solape entre MBRs de un mismo nivel. Por tanto, el
tiempo de procesamiento de consultas se mejora notablemente. En [BKS
+
90] se muestra que
el R*-tree tiene un mejor rendimiento que el R-tree convencional del orden del 50% para
consultas espaciales.
La idea de aplazar el proceso de divisin de nodos cuya capacidad ha sido superada fue
tambin incorporada en la implementacin de Hilbert R-tree [KaF94]. En esta nueva versin
del R-tree se utilizan los valores que devuelve la curva de Hilbert para imponer un orden
lineal sobre los MBRs, de esta manera se define quin es el hermano de un MBR dado, y
posteriormente aplicando la poltica de divisin de 2-a-3 (o generalizando, de s-a-(s+1)) de
los B*-tree. Otra caracterstica del Hilbert R-tree es que en los nodos internos tambin se
almacena el valor Hilbert ms grande de los MBRs del subrbol del que l es raz (adems del
MBR y el puntero al subrbol correspondiente), facilitando considerablemente la insercin de
nuevos objetos. Para el caso del Hilbert R-tree, al igual que ocurre con el R*-tree, genera una
mejor distribucin del espacio que el R-tree convencional, y adems tiene un tiempo de
respuesta mejor, debido a que el rbol es ms compacto y reducido.
En [BKK96] se ha propuesto una modificacin del R*-tree, denominada X-tree, que por
los resultados presentados en dicho artculo es un mtodo de acceso muy apropiado para la
indexacin de datos multidimensionales. El X-tree reduce el solape entre MBRs de nodos
internos utilizando un nuevo concepto, el supernodo. Este mtodo de acceso aplaza la divisin
Captulo 2
24
de nodos introduciendo supernodos, es decir, nodos con una capacidad mayor que la del
tamao mximo de un bloque normal. Adems, para encontrar la divisin ms apropiada, el
X-tree tambin mantiene la historia de las divisiones anteriores.
En la Tabla 2.2 podemos observar los mtodos de accesos espaciales ms representativos
de la familia del R-tree k-dimensional.

Nombre Antecedente Regin Reinsercin Caractersticas
R-tree [Gut84] B-tree MBRs Solapados No Varios criterios para la divisin.
Bsquedas por varios caminos.
Hilbert R-tree
[KaF94]
R-tree MBRs Solapados S El criterio de divisin se basa en los
valores de la curva de Hilbert asociado a
los centros de los objetos.
R*-tree
[BKS
+
90]
R-tree MBRs Solapados S Minimizar el solape entre los MBRs que
forman un nodo. Coste adicional de la
reinsercin antes de realizar la divisin.
R
+
-tree
[SRF87]
R-tree MBRs Disjuntos No Redundancia de objetos. Divis in en
cascada. No garantiza pginas llenas.
X-tree
[BKK96]
R-tree MBRs Solapados No La estructura no es homognea, puesto
que puede haber nodos de gran tamao
(supernodos). El criterio de divisin
depende del solape y de la historia de la
divisin en una determinada dimensin.
TV-tree
[LJF94]
R-tree Esferas solapadas
con dimensin
reducida
S El criterio de insercin est
condicionado al nmero de regiones
solapadas, al nmero de dimensiones
inactivas y al radio de la regin.
SS-tree
[WhJ96]
R-tree Esferas Solapadas S La estructura es compleja y el criterio
de insercin depende de la proximidad
al centro de la esfera. Las bsquedas
pueden necesitar seguir varios caminos.
SR-tree
[KaS97]
R-tree MBRs y esferas
solapados
S Existe solapamiento, pero menor que
para el SS-tree.
Tabla 2.2 Clasificacin de los mtodos de acceso ms representativos de la familia del R-
tree k-dimensional.
Otras variantes del R-tree consideran formas ms generales para la mnima envolvente de
objetos espaciales, tratando de minimizar los espacios muertos que se pueden producir en un
MBR. En [Gn89] se propone el Cell tree, cuya principal caracterstica es que en los nodos
hoja se almacenan poliedros convexos que envuelven a los objetos de nivel inferior, en lugar
de almacenar MBRs. En [Jag90] se propone el P-tree (polygon tree), donde las mnimas
envolventes son polgonos con inclinacin de las caras de 0, 45, 90 y 135 grados. Mnimas
formas envolventes que son cncavas o incluso tienen huecos han sido sugeridas en [LoS90]
para definir el hB-tree.

2.5 Consultas espaciales

Mtodos de acceso espaciales basados en MBRs. El R*-tree
25
En [Bec92] se presenta un lenguaje de consulta formal que soporta el planteamiento de
consultas sobre estructuras de archivos multidimensionales, tales como proyecciones,
selecciones y joins. Despus, se aplica dicho lenguaje para formular consultas estndar
(consulta exacta, consulta en rango, equijoin y semijoin) y geomtricas (consulta para la
localizacin de un punto, consulta de ventana, consulta de solape, join espacial, etc.).
Nosotros slo vamos a tratar las consultas que se aplican sobre mtodos de acceso espaciales,
denominadas consultas espaciales.
Segn [Gag98], un objeto O en un sistema de bases de datos espacial normalmente est
definido por varios atributos no espaciales y por un atributo de algn tipo de dato espacial
(punto, lnea, regin, polgono, etc.). Este atributo espacial describe la geometra del objeto O,
y lo denotamos como O.geo. La geometra de objetos espaciales es muy compleja, ya que se
formula en base a parmetros como por ejemplo: nmero de vrtices que forman dichos
objetos, la distribucin de los mismos en el espacio, sus formas, etc.
Los mtodos de acceso espaciales organizan los objetos espaciales en base a su clave
geomtrica. El MBR es la clave geomtrica ms popular [BKS
+
94]. Utilizar el MBR como
aproximacin del objeto espacial original reduce la complejidad del objeto a los dos puntos
que determinan el rectngulo mnimo (caras paralelas a los ejes coordenados) que cubre al
objeto y conserva las caractersticas ms importantes del objeto espacial que son su posicin y
su extensin.
Los objetos espaciales se gestionan mediante operaciones espaciales. Una operacin
espacial la podemos definir como una funcin con argumentos espaciales, es decir, dicha
funcin toma objetos espaciales como operandos y devuelve objetos espaciales o valores
escalares como resultado. En [Sch97] se clasifican los operadores espaciales en las siguientes
categoras:
Predicados espaciales que devuelven valores booleanos.
Operaciones espaciales que devuelven valores numricos.
Operaciones espaciales que devuelven componentes de un objeto espacial.
Operaciones espaciales que devuelven objetos espaciales.
Operaciones espaciales sobre conjuntos de objetos referenciados espacialmente.
En esta tesis nos centraremos en las dos operaciones espaciales relacionadas con los
predicados espaciales que devuelven valores booleanos (verdadero o falso) y las operaciones
espaciales que devuelven valores numricos.
La categora de las operaciones espaciales que devuelven valores numricos contiene
operaciones que calculan una propiedad mtrica de un objeto espacial y devuelve un valor
escalar:
La operacin rea devuelve el rea de un objeto regin, mientras que la operacin
permetro devuelve el valor del permetro de una regin espacial.
Captulo 2
26
La operacin longitud calcula la longitud total de un objeto lnea.
El dimetro de un objeto espacial se define como la distancia ms larga entre
cualquier par de sus componentes.
En esta categora tambin tenemos a las operaciones relacionadas con la distancia. La
operacin distancia (d) calcula la distancia entre dos puntos, que es siempre un valor
mayor o igual que cero, d : (P
1
, P
2
)
+
. La distancia entre dos objetos viene
determinada por las operaciones mindist y maxdist. Las operaciones mindist y maxdist
calculan la distancia mnima y mxima entre dos objetos espaciales.
Las operaciones de direccin calculan los ngulos entre dos objetos espaciales como
un nmero real en el rango desde 000 hasta 3595959.
Otra operacin que devuelve valores numricos es la que determina el nmero de
componentes (cardinalidad) de un conjunto de objetos espaciales formados por puntos,
lneas o regiones.
Las operaciones espaciales que devuelven valores booleanos estn asociadas a predicados
espaciales que pasamos a definir a continuacin.
Definicin. Predicado espacial y Frmula atmica espacial.
Un predicado espacial, (), es la formalizacin de una propiedad espacial. Un predicado
espacial ser unario, binario o n-ario en funcin del nmero de objetos espaciales
(argumentos) que compare. (), aplicado a objetos espaciales definidos sobre alguna
coleccin no vaca de atributos {A
1
, A
2
, ..., A
k
} en el espacio Eucldeo k-dimensional, E
(k)

(espacio multidimensional de datos dotado de la distancia Eucldea), es una funcin
booleana aplicada a dichos objetos sin ningn efecto lateral sobre ellos, permitiendo
verificar alguna propiedad espacial entre los mismos.
() : f() {verdadero, falso}
A estos predicados espaciales con sus argumentos se les conoce con el nombre de frmulas
atmicas espaciales.
Definicin. Sentencia espacial.
Una sentencia espacial, (), es un conjunto de frmulas atmicas espaciales con conectores
lgicos ( (and), (or) y (not)).
Por ejemplo: () :
1
()
2
() ...
n
(), () :
1
()
2
() ...
n
(), () :
1
()

2
()
3
() ...
n
()
La evaluacin de una sentencia espacial se podr llevar a cabo si es una sentencia espacial
cerrada. Una sentencia espacial cerrada es una sentencia espacial que al depender de
variables espaciales se le puede atribuir un valor de verdad o falsedad {verdadero, falso}. Una
variable espacial abarca a todos los elementos con naturaleza espacial que estn almacenados
en la base de datos, lo cual significa que la variable espacial puede adoptar como valor,
cualquier objeto espacial de ella. Por lo tanto, para fijar valores de variables espaciales dentro
de una sentencia espacial basta con hacer una asignacin de un objeto espacial (constante) a
esa variable espacial. Tambin puede ocurrir que la evaluacin de una sentencia espacial no
Mtodos de acceso espaciales basados en MBRs. El R*-tree
27
venga referida a constantes, sino que est referida a todos o alguno (al menos uno) de los
valores de una variable, para ello hay que aadirle algn smbolo que exprese su validez, y
stos son los cuantificadores (, cuantificador universal y , cuantificador existencial). Por
ejemplo:
x : (x, y), x : (x, y)
En lo sucesivo llamaremos predicado espacial tanto para referirnos a un predicado espacial
(frmula espacial atmica) como para las sentencias espaciales.
Una consulta espacial en la que intervienen objetos espaciales, donde hay un conjunto de
atributos o extensin espacial (O.geo) en cada uno de ellos, est descrita por:
El tipo de dato espacial (punto, lnea, regin, etc.) que representa dicho conjunto de
atributos.
El predicado espacial que deben satisfacer los objetos resultantes.
Definicin. Consulta espacial.
Una consulta espacial aplicada a un objeto espacial O definido en el espacio Eucldeo k-
dimensional, E
(k)
(espacio multidimensional de datos dotado de la distancia Eucldea), es un
conjunto de objetos que satisfacen un determinado predicado espacial definido en base a
propiedades espaciales.
Q(O) = {O : (O, O)}
donde O es una variable espacial y (O, O) es un predicado espacial en el que intervienen
las variables espaciales O y O.
Para el predicado espacial existe un amplio abanico de posibilidades que est
estrechamente ligado a las relaciones espaciales que se pueden dar entre determinados objetos
espaciales. Entre ellas destacan l as relaciones topolgicas, que caracterizan propiedades como
continuidad, adyacencia, solape, inclusin, conectividad, etc. Otras relaciones espaciales
conocidas son las mtricas (distancias o direcciones) y las de orden espacial.
Como acabamos de ver, el resultado de una consulta espacial es un conjunto de objetos
espaciales que verifican un determinado predicado espacial. A continuacin, al igual que en
[GaG98], vamos a realizar la definicin formal de los tipos de consultas espaciales ms
comunes.
Tipo de Consulta Espacial 1. Consulta Exacta. CE.
Dado un objeto O con extensin espacial O.geo E
(k)
, encontrar todos los objetos O con la
misma extensin espacial que O.
CE(O) = {O : O.geo = O.geo}
Tipo de Consulta Espacial 2. Consulta para la Localizacin de un Punto. CLP.
Dado un punto p E
(k)
, encontrar todos los objetos O que se solapan con p.
CLP(P) = {O : p O.geo = p}
Captulo 2
28

Tipo de Consulta Espacial 3. Consulta en Rango o Consulta de Ventana. CR.
Dado un k-rectngulo R E
(k)
definido en base a los dos puntos de su diagonal mayor,
encontrar todos los objetos O que tienen al menos un punto en comn con R.
CR(R) = {O : R O.geo }
Debemos destacar que las caras del k-rectngulo R son paralelas a los ejes de coordenadas.
Un tipo ms general de consulta sera aquella que permite la bsqueda de regiones que tienen
diferentes orientaciones y formas. Por ejemplo, dado un punto y una distancia (radio)
tendramos una consulta en rango sobre una hiperesfera definida en el espacio Eucldeo k-
dimensional, E
(k)
.
Tipo de Consulta Espacial 4. Consulta de Solape. CS.
Dado un objeto O con extensin espacial O.geo E
(k)
, encontrar todos los objetos O que
tienen al menos un punto en comn con O.
CS(O) = {O : O.geo O.geo }
Tipo de Consulta Espacial 5. Consulta de Cubrimiento. CCu.
Dado un objeto O con extensin espacial O.geo E
(k)
, encontrar todos los objetos O que
cubren a O.
CCu(O) = {O : O.geo O.geo = O.geo}
Tipo de Consulta Espacial 6. Consulta de Inclusin. CIn.
Dado un objeto O con extensin espacial O.geo E
(k)
, encontrar todos los objetos O
cubiertos por O (todos los objetos O que estn incluidos en O).
CIn(O) = {O : O.geo O.geo = O.geo}
Las consultas de cubrimiento (CCu) e inclusin (CIn) son simtricas entre ellas. Estos dos
tipos de consultas espaciales son casos particulares y ms restrictivos de la consulta de solape
(CS), ya que especifica que el resultado de la operacin ser uno de los dos objetos espaciales
de entrada.
Tipo de Consulta Espacial 7. Consulta de Adyacencia. CA.
Dado un objeto O con extensin espacial O.geo E
(k)
, encontrar todos los objetos O
adyacentes a O.
CA(O) = {O : O.geo O.geo O.geo
o
O.geo
o
= }
Donde O.geo
o
y O.geo
o
representan los interiores (sin considerar las fronteras o bordes) de
las extensiones espaciales de O.geo y O.geo, respectivamente.
Tipo de Consulta Espacial 8. Consulta del Vecino ms Prximo. CVP.
Dado un objeto O con extensin espacial O.geo E
(k)
, encontrar el objeto O con extensin
espacial O.geo E
(k)
, que tiene una distancia mnima desde O.
CVP(O) = {O : O O, d(O.geo, O.geo) d(O.geo, O.geo)}
Mtodos de acceso espaciales basados en MBRs. El R*-tree
29
Debemos destacar que la distancia Eucldea, d, entre objetos espaciales se define
normalmente como la distancia entre sus puntos ms prximos. Otra funcin de distancia muy
conocida, aparte de la distancia Eucldea, es la distancia Maniatan [Bes5].
Tipo de Consulta Espacial 9. Join Espacial. JE.
Dados dos conjuntos de objetos espaciales P y Q, y un predicado espacial , encontrar todos
los pares de objetos espaciales (O, O) P Q, donde la evaluacin del predicado espacial
(O.geo, O.geo) es cierta.
JE(P, Q, ) = {(O, O) PQ : (O.geo, O.geo)}
Para el predicado espacial existe una amplia gama de posibilidades tal como se puede
comprobar en [ArS94, BHF93, BKS93a, BKS
+
94, VaR94, Gn93, LoR94, Ore86, PTS95,
Rot91, ShA97]. Estas posibilidades para incluyen entre otros: solapa, cubre_a,
cubierto_por, noroeste, adyacente, encuentra, etc. Si estudiamos las caractersticas
topolgicas de cada predicado espacial podemos observar que el predicado solapa juega un
papel importante en todos los casos, como por ejemplo en contiene, cubierto_por o
adyacente.

2.6 R*-tree

El R*-tree, al igual que el R-tree convencional, es una estructura de datos basada en MBRs,
arbrea, multidimensional, balanceada en altura y almacenada en disco. Esta estructura de
datos fue propuesta en [BKS
+
90] para solucionar el principal inconveniente que presentaban
los R-trees en el procesamiento de consultas espaciales. El problema consista en la
posibilidad de que exista un elevado ndice de solape entre los MBRs que hay en los nodos de
un mismo nivel en el R-tree, provocando una reduccin del rendimiento ante tales
operaciones. Adems, en [BKS
+
90] se confirma la observacin hecha en [RoL85], de que un
factor clave para el rendimiento de un R-tree respecto al procesamiento de consultas es la
organizacin de los MBRs en dicho mtodo de acceso durante el proceso de insercin.

2.6.1 El R-tree como base para el R*-tree

El R-tree [Gut84] es una estructura de datos arbrea multidimensional basada en MBRs,
balanceada en altura y almacenada en disco, derivada del B
+
-tree [Com79]. Este mtodo de
acceso es apropiado tanto para la indexacin de puntos como de objetos en un sistema de
bases de datos espacial. Los puntos, MBRs u objetos se almacenan en los nodos hoja del rbol
o en un archivo k-dimensional de datos asociado al R-tree, mientras que en los nodos internos
estn los MBRs que cubren el rea de los elementos del rbol que hay en un nivel inferior.
Los nodos hoja contienen punteros a los objetos o punteros nulos si en ellos se almacenan
puntos o MBRs, en lugar de punteros a sus nodos hijo como ocurre con los nodos internos. De
Captulo 2
30
forma general, podemos decir que esta estructura arbrea multidimensional organiza una
coleccin de objetos representados por sus MBRs.
A menudo, los nodos se corresponden con pginas de disco, y por tanto los parmetros
para definir el rbol se escogen con el objetivo de optimizar el procesamiento de una consulta
sobre l. Ntese que en un R-tree los MBRs que estn en nodos internos pueden solaparse, es
decir, MBRs en diferentes entradas de un nodo pueden tener un rea de solape comn. ste es
un inconveniente importante del R-tree convencional, puesto que si hay un elevado ndice de
solape entre los MBRs que forman el R-tree puede producir un bajo rendimiento en el
procesamiento de consultas, ya que es necesario visitar varios nodos para determinar si un
objeto determinado est en el rbol.
En la Figura 2.5 se ilustran algunos MBRs l a izquierda (Figura 2.5.a) y la correspondiente
estructura de archivo para el R-tree de orden (3, 4) en la derecha (Figura 2.5.b), donde los
nodos se corresponden con pginas del archivo de datos. Adems, en dicha figura podemos
observar la principal caracterstica del R-tree: MBRs definidos en el mismo nivel pueden
solaparse (A, B y C). Debemos notar tambin que el R-tree no es nico, ya que la estructura
del mismo est fuertemente condicionada por el orden en el que se inserten (o se borren) los
MBRs en el rbol.

A B C
D E G F H I K J L M N
G
F
E
D
A
K
J
H
B
I
N
M
L
C
(a) (b)

Figura 2.5 Un ejemplo de R-tree.
El algoritmo para la insercin de un MBR en un R-tree es muy similar al utilizado para
los B
+
-trees. Los nuevos MBRs se aaden en los nodos hoja. Para determinar el nodo hoja
apropiado para la insercin debemos recorrer el R-tree empezando desde la raz y en cada
paso escoger el subrbol cuyo MBR correspondiente tendra que expandirse lo mnimo
posible. Si hay varios MBRs que cumplen este criterio, entonces se escoge, entre ellos, el que
tiene menor rea. Una vez que el nodo hoja ha sido determinado, se realiza una comprobacin
para ver si el MBR a insertar puede provocar un desbordamiento en el nodo (exceda su
capacidad mxima, M). Si no ocurre desbordamiento ajustamos apropiadamente el MBR que
lo cubre, si es necesario, y propagamos el cambio hacia arriba (desde la hoja hacia la raz). Si
ocurre desbordamiento, entonces el nodo debe dividirse, y las M + 1 entradas del nodo deben
distribuirse en dos nodos. Dicha divisin se propaga en el rbol hacia la raz, si es necesario, y
se realizan los ajustes pertinentes de los MBRs.
Existen muchas formas de dividir un nodo. Una posible alternativa sera distribuir las
entradas del nodo que ha excedido su capacidad mxima (tendra M + 1 entradas) entre dos
nodos, tal que la probabilidad con la que ambos nodos se visitarn en operaciones de
bsqueda posteriores se reduzca al mximo. Esto se consigue minimizando el rea total de los
Mtodos de acceso espaciales basados en MBRs. El R*-tree
31
MBRs que cubren ambos nodos (factor de cobertura). Otra alternativa es reducir la
probabilidad de que ambos nodos se examinen en operaciones de bsqueda posteriores. Esto
se consigue minimizando el rea comn de ambos nodos (factor de solape). Debemos destacar
que estas dos alternativas pueden ser contradictorias si se aplican al mismo tiempo. En la
Figura 2.6 podemos comprobar esta situacin, donde la lnea discontinua representa el MBR
asociado a las nuevas particiones de MBRs que resultan de tratar el nodo desbordado segn
las alternativas anteriores. Consideremos los cuatro MBRs que se muestran en la Figura 2.6.a
y supongamos que estn en un nodo que ha excedido su capacidad mxima (M = 3) entonces
se tendra que realizar la divisin. La primera alternativa (minimizar el factor de la cobertura)
se cumple para la divisin en la Figura 2.6.b puesto que se minimiza el rea que cubre a los
MBRs que estaran distribuidos en dos nodos, y la segunda (minimizar el factor de solape) en
la Figura 2.6.c, ya que se minimiza el rea comn a los MBRs que cubren a los dos nuevos
nodos generados por la divisin.

(a) (b) (c)

Figura 2.6 Alternativas para la divisin de un nodo que ha excedido su capacidad mxima.
En [Gut84] se presenta el rendimiento de tres algoritmos para la divisin de nodos basados
en minimizar el rea total del MBR que cubre a los MBRs que estaran distribuidos en los dos
nodos resultantes (la primera alternativa descrita anteriormente y mostrada en la Figura 2.6.b).
El primero es un algoritmo exhaustivo que trata todas las posibilidades y tiene un coste
exponencial en M. En tal caso hay que examinar un nmero de posibles particiones igual a 2
M

1. Ya que para un conjunto de M + 1 elementos (nodo desbordado), hay 2
M+1
posibles
particiones. De entre todas ellas, eliminamos el conjunto vaco, el conjunto con M + 1
elementos, y todas las particiones duplicadas, obteniendo (2
M+1
2)/2 = 2
M
1 particiones.
Esta tcnica es impracticable para la mayora de los valores de M, puesto que la complejidad
del algoritmo es de orden exponencial.
El segundo algoritmo tiene un coste cuadrtico en M y lineal en el nmero de dimensiones
k, e intenta encontrar una particin con un rea lo suficientemente pequea sin llegar a
garantizar que determina la particin con el rea ms pequea posible. Primero, encuentra los
dos MBRs que generaran el rea ms grande si estuvieran en el mismo nodo. Esto se calcula
restando la suma de las reas de los dos MBRs del rea del MBR que los cubre. Cada uno de
los dos MBRs se ubica en nodos diferentes, por ejemplo s y t. A continuacin, se examinan
los restantes MBRs y para cada uno, por ejemplo el MBR r, se calcula
rs
y
rt
, que son los
incrementos en el rea de los MBRs que cubren los nodos s y t cuando el MBR r se aade a
ellos. El objetivo principal es encontrar el MBR n tal que (
ns

nt
( tiene el valor mximo,
Captulo 2
32
y entonces aadir el MBR n al nodo actual que provoque un aumento de rea ms pequeo.
Todo este proceso se realiza para cada uno de los MBRs que vayan quedando de los M + 1
originales que haba en el nodo desbordado.
El tercer algoritmo tiene un coste lineal en M y en el nmero de dimensiones k. Primero,
encuentra los dos MBRs con la separacin normalizada ms grande a lo largo de todas las
dimensiones. Por ejemplo, suponiendo que el origen est en la esquina superior izquierda del
espacio, en la dimensin vertical estn los MBRs con el lado inferior mximo y con el lado
superior mnimo. Despus, los MBRs restantes se procesan en un orden arbitrario y cada
MBR se ubica en el nodo que provoque un menor aumento de rea para el MBR que los cubre
cuando ste se aade.
En [Gut84] se muestran una serie de experimentos utilizando los tres algoritmos de
divisin para consultas sobre los R-trees generados (anlisis basado en tiempo de ejecucin y
en nmero de accesos a disco), llegando a la conclusin de que no hay grandes diferencias
entre los tres. De esta manera, el algoritmo de divisin lineal (ms rpido) se escogi como
preferible aunque la calidad de la divisin fue inferior en algunos casos.
El algoritmo de borrado de un MBR dado (R) que se propone en [Gut84] para el R-tree,
primero se localiza el nodo hoja, por ejemplo H, donde se encuentra el MBR R, borrndose R
de H si la bsqueda ha sido satisfactoria. Despus, si el borrado del MBR no provoca que el
nmero de entradas de H sea inferior a m (capacidad mnima del nodo), conocido como
underflow, comprobamos si el mnimo rectngulo que lo cubre se puede reducir. Si es as, se
realiza el ajuste apropiado y lo propagamos desde la hoja hacia la raz. Por otro lado, si el
borrado de R provoca que la capacidad del nodo sea inferior a m, entonces aadimos el
contenido del nodo en una lista temporal T, y borramos este nodo del ndice. Entonces, este
proceso de borrado se propaga desde la raz a las hojas realizando los ajustes necesarios de los
MBRs. Si una vez alcanzada la raz, sta tiene slo un hijo, entonces dicho hijo se convierte
en la nueva raz. Finalmente, reinsertamos todos los MBRs hurfanos de la lista temporal T en
la raz. Los elementos de T que corresponden a entradas de nodos hoja se ubican
apropiadamente en nodos a nivel de hoja, mientras que los elementos que se corresponden con
entradas de nodos internos se ubican en el mismo nivel que tenan en el R-tree antes de
realizar el proceso de borrado, ya que de ellos dependen subrboles. Alternativamente,
podemos mezclar los MBRs hurfanos con nodos hermanos como ocurren en los B
+
-trees,
aunque en [Gut84] se utiliza la reinsercin por dos motivos: (1) se puede hacer uso del
algoritmo de insercin, y (2) este proceso refina incrementalmente la estructura espacial del
rbol y evita el deterioro que ocurrira cuando se combinan entradas hurfanas con nodos
adyacentes.
El algoritmo de bsqueda de MBRs u objetos en un R-tree no es difcil de llevar a la
prctica. El nico problema que surge cuando intentamos encontrar un determinado objeto es
que puede ser necesario examinar varios caminos (subrboles), ya que puede haber solape
entre MBRs a un mismo nivel y para encontrar el objeto en cuestin puede ser necesario
recorrerlos todos ellos.


Mtodos de acceso espaciales basados en MBRs. El R*-tree
33
2.6.2 Caractersticas principales del R*-tree

El diseo del R*-tree como mtodo de acceso espacial introduce una nueva poltica para la
insercin denominada, reinsercin forzada. En ella, si un nodo se desborda por primera vez
en un determinado nivel, no se realiza la divisin del mismo de forma inmediata, sino que
primero se extraen w entradas de dicho nodo y despus se reinsertan en el R*-tree. El
parmetro w puede variar, aunque en [BKS
+
90] se propuso establecer w al 30% del nmero
mximo de entradas por nodo (w = 0.3 * M). Existen dos razones fundamentales para emplear
la reinsercin forzada. Primero, este proceso puede reducir considerablemente el nmero de
divisiones de nodos desbordados. Segundo, la aplicacin de esta tcnica es muy importante
para reorganizar dinmicamente el R*-tree.
Otro aspecto importante de los R*-trees est relacionado con la poltica de divisin de
nodos desbordados (overflow). Mientras que en los R-trees convencionales presentados en
[Gut84] slo se trata de minimizar el rea que cubre a las regiones de los nodos resultantes, el
R*-tree tambin tiene en cuenta los siguientes objetivos:
1. Se debe minimizar el solape (overlap) entre regiones minimales cubiertas por nodos
que estn en el mismo nivel del rbol. Cuanto menor sea el solape entre MBRs, menor
es la probabilidad de tener mltiples caminos de bsqueda.
2. Se debe minimizar tambin los permetros de los MBRs. El MBR preferido es el que
tiene forma cuadrada, ya que es la representacin rectangular ms compacta.
3. Se debe maximizar la utilizacin del almacenamiento.
Los algoritmos para la divisin de nodos en el R*-tree estn basados en la tcnica del
Barrido del Plano (plane-sweep) [PrS88]. Para k dimensiones, la complejidad de los
algoritmos de divisin de nodos es de O(k*N*logN) para un nodo con N MBRs [BKS
+
90].
La eficiencia de las consultas sobre R*-trees depende de lo buena que sea la distribucin
de MBRs en los nodos. Por ello, el algoritmo de insercin de objetos en un R*-tree es la fase
ms importante de cara a tener un buen rendimiento para las consultas (rbol ms compacto y
reducido). El algoritmo de insercin de objetos en un R*-tree es completamente diferente al
utilizado por los R-trees convencionales. Segn [BKS93a, YuM98], las dos caractersticas
principales que diferencian al R*-tree del R-tree original son las siguientes:
En primer lugar, cuando un MBR se inserta en un nodo lleno (desbordndose, con un total
de M + 1 entradas) en el R*-tree, generalmente el nodo no se divide inmediatamente, sino que
una fraccin de sus entradas se extrae y se reinserta en el mismo nivel del R*-tree. Las
entradas que se extraen para despus reinsertarlas se seleccionan de forma que tengan la
mayor distancia desde el centro del MBR original del nodo. La reinsercin de entradas
aumenta la utilizacin del almacenamiento mejorando la calidad de la divisin (reduciendo el
solape entre MBRs) y hace que el rendimiento sea casi independiente de la secuencia de
insercin. Si durante el proceso de reinsercin en un nivel del R*-tree, un nuevo MBR debe
insertarse en un nodo lleno, entonces el nodo debe dividirse en dos, aplicando el algoritmo de
divisin de un nodo que indicamos a continuacin.
Captulo 2
34
En segundo lugar, el algoritmo para la divisin de un nodo desbordado (con M + 1
entradas) en un R*-tree es totalmente diferente del que se lleva a cabo sobre el R-tree original.
Primero se debe determinar la dimensin donde se va a realizar la divisin. Para cada
dimensin, se ordenan todas las entradas con respecto a los valores ms bajos de los
intervalos, se consideran todas las posibles particiones del nodo desbordado en dos grupos
con al menos m entradas cada uno respetando la ordenacin, M 2m + 2 (donde M y m es la
capacidad mxima y mnima de un nodo, respectivamente), y se suman los permetros de l os
MBRs de todas las posibles particiones. Repetimos el mismo proceso con las entradas
ordenadas respecto a los valores ms altos de los intervalos en cada dimensin. La dimensin
con el menor valor de suma de permetros se escoge como eje de divisin. En segundo lugar
(una vez seleccionado el eje de divisin), se considera de nuevo el conjunto con las M + 1
entradas ordenadas con respecto a los valores ms bajos de los intervalos obtenidos de la
proyeccin de los MBRs sobre el eje de divisin. Este conjunto se divide en dos subconjuntos,
que se consideran como nodos diferentes del R*-tree. El nmero de entradas de un
subconjunto y otro vara entre m y M m + 1. Por ltimo, entre todas las posibles particiones,
M 2m + 2, se escogen las dos particiones con menor rea de solape entre los MBRs que las
forman. Si dos o ms particiones tienen la misma mnima rea de solape, entonces escogemos
de todas ellas, la particin con la menor suma de rea.
En [BKS
+
90] se presenta una amplia seccin experimental con varias distribuciones de
MBRs y se indica que el R*-tree funciona considerablemente mejor que las variantes
propuestas en [Gut84] para el R-tree original segn los siguientes parmetros comparativos:
consultas para la localizacin de un punto, consultas en rango, inserciones y utilizacin del
almacenamiento.
A continuacin se van a describir los algoritmos de insercin, borrado y bsqueda de
MBRs en un R*-tree, que se ilustrarn en base a la estructura de datos representada en la
Figura 2.7. En la parte izquierda (Figura 2.7.a) se muestran varios MBRs bidimensionales y la
correspondiente estructura de archivo para el R*-tree de orden (2, 3) a la derecha (Figura
2.7.b), donde los nodos del rbol se corresponden con pginas del archivo.

5
R1 R2 R3 R4 R8 R5 R6 R7
8
2
3
4
7
6
1
23
22
21
X
Y
(0, 0)
R21 R22 R23
(a) (b)

Figura 2.7 Un ejemplo de R*-tree.



Mtodos de acceso espaciales basados en MBRs. El R*-tree
35
2.6.3 Algoritmos para el mantenimiento de un R*-tree

Como sabemos, los R*-trees son ndices arbreos que organizan dinmicamente un conjunto
de objetos k-dimensionales representados por sus MBRs k-dimensionales. Al ser estructuras
de datos dinmicas deben adaptarse al crecimiento o disminucin de la informacin contenida
en ellas de manera adecuada, siendo capaces de gestionar grandes volmenes de datos de alta
dimensionalidad. Por tanto, operaciones de insercin, borrado y bsqueda se deben de poder
llevar a cabo sobre dichos mtodos de acceso sin deteriorar el tiempo de procesamiento. En
los siguientes epgrafes, se van a describir los algoritmos de insercin, borrado y bsqueda de
MBRs en un R*-tree, que son la base para el mantenimiento de dicho ndice arbreo.

2.6.3.1 Algoritmo de insercin

Sea N un nodo interno de un R*-tree, cuando insertamos un MBR S, en un nodo hijo de N, se
necesita escoger algn MBR, por ejemplo R, en N como el MBR padre de S. Puede que R
necesite agrandarse para contener a S. Una tcnica de optimizacin es escoger a R en N tal
que necesite la menor expansin de solape para contener a S. Evidentemente, cuando R se
agranda, el factor de solape de R en N es probable que se incremente. Tambin es evidente
que si R contiene ya a S, entonces no se necesita ninguna expansin para R. Minimizando el
solape se tiende a minimizar el nmero de subrboles que hay que seguir para realizar las
operaciones de bsqueda.
Definicin. Solape de un MBR R con un nodo N de un R*-tree.
Sea N un nodo interno de un R*-tree. El solape de un MBR R en N es la suma de las reas
solapadas de los otros MBRs de N con R.
En la Figura 2.8, mostramos en primer lugar (Figura 2.8.a) varios de los MBRs incluidos
en un nodo N, y en segundo (Figura 2.8.b) lugar el solape de R en N.

Solape de R = + +
R
(a) (b)

Figura 2.8 Solape de R en N.
Captulo 2
36
Para presentar la descripcin del algoritmo de insercin en un R*-tree consideramos los
siguientes parmetros: sea T el puntero a la raz del R*-tree y (S, P
S
) el par a insertar, donde
P
S
es la direccin del puntero al elemento (nodo u objeto) que cubre al MBR S. Adems
debemos considerar a L, que inicialmente es el nodo raz, como el nivel donde va a ser
insertado el par (S, P
S
). Cada nivel tiene un indicador de desbordamiento, mostrando si ha
ocurrido un desbordamiento en dicho nivel. Al principio todos los indicadores de
desbordamiento de todos los niveles estn desactivados.
Insertar(S, P
S
, L, T)
1. Seleccionar un nodo N en el nivel L para insertar S. Esto se lleva a cabo recursivamente
desde el nodo raz hasta el nodo con nivel L. Si N es un nodo en el nivel L, devuelve N.
En otro caso, se selecciona un subrbol para descender, y esto se hace escogiendo una
entrada apropiada en N. Para ello debemos considerar los dos casos siguientes:
1.1. Si N es el nodo padre de nodos hoja, se escoge la entrada de N cuyo MBR
correspondiente necesite la menor expansin de solape para contener a S. Si varios
MBRs en N necesitan la misma expansin de solape para contener a S, se escoge el
MBR cuya rea necesita la menor expansin para contener a S (debemos destacar
que los conceptos de rea de un MBR y solape de un MBR en N son conceptos
diferentes). Si de nuevo existen varios MBRs en N con la menor rea de expansin
para contener a S, entonces se escoge de entre ellos el MBR con la menor rea.
1.2. Si N no es ni un nodo hoja ni el nodo padre de nodos hoja, entonces se escoge el
MBR en N cuya rea necesita la menor expansin para contener a S. Si existen
varios MBRs con la menor rea de expansin para contener a S, entonces se escoge
de entre ellos el MBR con la menor rea.
Sea (R, P) la entrada de N escogida para contener a S. Reemplazamos T por P y
continuamos el proceso de seleccin de un nodo en el nivel L para insertar S.
2. Sea N el nodo en el nivel L devuelto en el paso 1. Si N tiene espacio suficiente para
contener (el nmero de entradas de N es menor o igual que M, siendo M la capacidad
mxima de un nodo) al par (S, P
S
), lo insertamos en N y salimos del procedimiento. En
otro caso se produce un desbordamiento (el nmero de entradas de N es M + 1). Para
gestionar el desbordamiento ejecutamos el paso 3.
3. Comprobar el indicador de desbordamiento en el nivel L para ver si ste es el primer
desbordamiento que se produce en dicho nivel. Si lo es (el indicador de desbordamiento
est an desactivado) y N no es el nodo raz, entonces activar el indicador de
desbordamiento para el nivel L y ejecutar el paso 4. En caso contrario, ir al paso 5.
Debido a que el nivel de la raz del R*-tree tendr siempre un solo nodo, la reinsercin a
este nivel no tiene sentido. Por tanto, si N es el nodo raz del rbol debemos ir
directamente al paso 5 para dividir el nodo.
4. Seleccionar w entradas de las M + 1 entradas que hay en N para la reinsercin. Esto se
lleva a cabo de la siguiente manera. Primero, se calculan las distancias entre los centros
de los M + 1 MBRs y el centro del MBR del nodo interno N. A continuacin, se
ordenan las M + 1 entradas en orden descendiente de las distancias. Las primeras w
Mtodos de acceso espaciales basados en MBRs. El R*-tree
37
entradas en esta lista de M + 1 entradas se escogen para la reinsercin, y el MBR del
nodo interno se ajustar convenientemente (reduciendo su tamao). Esta seleccin
tiende a mantener los MBRs que no se consideran para la reinsercin tan cercanos como
sea posible. Los experimentos llevados a cabo en [BKS
+
90] mostraron que w = 0.3*M
es una buena eleccin. Sea (S
i
, P
Si
) para i = 1, 2, ...,w las entradas seleccionadas para la
reinsercin. Se reinsertan todas estas entradas en orden ascendente de sus distancias
llamando a Insertar(S
i
, P
Si
, L, T), i = w, w-1, ...,1. Los resultados experimentales
llevados a cabo en [BKS
+
90] demostraron que la reinsercin de las w entradas en orden
ascendente de distancias funciona mejor que insertarlas w entradas en orden
descendente.
5. Dividir las M + 1 entradas en dos conjuntos para la distribucin en dos nodos. La
restriccin que debe cumplirse es que cada nodo necesita tener al menos m entradas.
Los pasos para el algoritmo de divisin se describen a continuacin.
5.1. Para la i-sima dimensin en el espacio k-dimensional (1ik), ordenamos las M + 1
entradas, primero por los valores ms bajos y despus por los valores ms altos de
los intervalos que forman los MBRs. Para cada conjunto ordenado, se consideran las
M 2m + 2 diferentes formas de distribuir las M + 1 entradas en dos subconjuntos
(particiones) con al menos m entradas y manteniendo el orden. La j-sima particin,
1 j M 2m + 2, es para establecer el primer conjunto que tiene las m 1 + j
primeras entradas y el segundo conjunto tiene las entradas restantes respetando el
orden. Debemos indicar como aclaracin, que las M 2m + 2 diferentes particiones
enumeran todas las posibles formas de dividir las M + 1 entradas en dos conjuntos de
tal forma que cada conjunto tiene al menos m entradas y ninguna entrada que aparece
en el primer conjunto aparece despus en el segundo conjunto de acuerdo con el
orden establecido. Para la j-sima particin, sea b
j1
y b
j2
los MBRs de los rectngulos
minimales en el primer conjunto y en el segundo conjunto, respectivamente. Sean p
j1

y p
j2
los permetros de b
j1
y b
j2
, respectivamente. Denotemos X
i
como la suma de los
permetros de todos los MBRs para la dimensin i-sima (1ik, ya que tenemos k
dimensiones), donde p
ij1
y p
ij2
representan la aportacin en la dimensin i al
permetro de p
j1
y p
j2
de la j-sima particin, respectivamente. La expresin X
i
de es
la siguiente:
( ) k i 1 p p X
m M
j
ij ij i


+

, ,
2 2
1
2 1

La dimensin con valor X
i
ms pequeo es denominada eje de divisin. Solo se
consideran las particiones basadas en la ordenacin sobre el eje de divisin para
identificar la mejor particin. Para minimizar an ms los valores de los permetros,
los MBRs de los nodos internos tienen la tendencia a convertirse en cuadrados, ya
que los cuadrados pueden agruparse ms fcilmente.
5.2. Entre las M 2m + 2 particiones a lo largo del eje de divisin, encontramos la
particin con la menor rea de solape entre b
j1
y b
j2
. Si dos o ms particiones tienen
la misma mnima rea de solape, entonces escogemos de entre todas ellas, la
particin con la menor suma de rea.
Captulo 2
38
5.3. Dividir las M + 1 entradas basadas en la particin escogida en 5.2 y utilizar los dos
nuevos nodos para reemplazar en nodo N. Dos nuevas entradas (de la forma (S, P
S
))
correspondientes a los dos nuevos nodos se generarn para el nodo padre de N (N
P
)
con el objetivo de reemplazar la antigua entrada. El MBR en cada nueva entrada (S)
es el MBR de los MBRs en el correspondiente nodo hijo. Si hay espacio suficiente en
N
P
para esta nueva entrada, se reemplaza la antigua por una de las nuevas y la
restante se aade al nodo N
P
, y finaliza el algoritmo. En otro caso (desbordamiento
en el nodo padre de N, N
P
), sustituimos N por N
P
, el nivel actual por el nivel del
padre (subimos un nivel en el R*-tree), marcamos como activo el indicador de
desbordamiento del nivel del padre de N y vamos al paso 3 para determinar si la
reinsercin o el algoritmo de divisin debera aplicarse para gestionar el
desbordamiento en el nodo padre, N
P
. La divisin de un nodo desbordado puede
propagarse a todos los niveles hasta llegar al nodo raz. Si el nodo raz necesita
dividirse, entonces se debe crear un nuevo nodo raz y la altura del rbol R*-tree se
incrementa en 1.
Para mostrar un ejemplo de insercin de un nuevo MBR en un R*-tree vamos a considerar
la Figura 2.7.a. Supongamos ahora que deseamos insertar un nuevo MBR en la base de datos
(MBR R9 en lnea de puntos) tal y como se muestra en la Figura 2.9.a, en el R*-tree asociado
que se muestra en la Figura 2.7.b. Para realizar la insercin empezamos por el nodo raz del
R*-tree. Debido a que ste es un nodo interno y es el padre de los nodos hoja, encontramos la
entrada en el nodo raz cuyo MBR necesita tener una menor expansin de solape para
contener el MBR R9. Supongamos que el MBR R21 cuya entrada es (R21, P
R21
), es el MBR
que verifica dicha condicin. Seguimos el R*-tree por el puntero asociado al MBR R21, que
denominamos P
R21
, y descubrimos que es el nodo hoja ms a la izquierda, que est formado
por los MBRs {R1, R2, R3}. Debido a que este nodo hoja no tiene suficiente espacio
(recordar que el R*-tree es de orden (m, M) = (2, 3)) para poder acomodar la nueva entrada
(R9, P
R9
), se produce un desbordamiento en dicho nodo. Ya que ste es el primer
desbordamiento que se produce a nivel de hoja, entonces se va a realizar una reinsercin.
Supongamos que seleccionamos la entrada correspondiente al MBR R1 (R1, P
R1
) para la
reinsercin. Por este motivo el MBR R21 necesita ajustarse para cubrir los MBRs {R9, R2,
R3} tal y como se muestra en la Figura 2.9.b. Para este ejemplo, el proceso de reinsercin nos
vuelve a causar otro desbordamiento a nivel de hoja. Esta vez necesitamos aplicar el proceso
de divisin sobre las cuatro entradas que hay (tres anteriores {R9, R2, R3}, ms la nueva
entrada que ha sido reinsertada (R1, P
R1
)) para dar lugar a dos nuevos nodos.

5
8
2
3
4
7
6
1
23
22
21
X
Y
(0, 0)
9
8
2
3
4
7
23
22
21
X
Y
(0, 0)
9
5
1
6
(a) (b)

Figura 2.9 Insercin del MBR R9.
Mtodos de acceso espaciales basados en MBRs. El R*-tree
39
Para empezar con el proceso de divisin del nodo desbordado tenemos que ordenar las
cuatro entradas a lo largo del eje X (dimensin 1) dando lugar a {R1, R9, R2, R3}, y a lo
largo del eje Y (dimensin 2) quedando {R9, R3, R1, R2}. En nuestro ejemplo, por cada eje
(dimensin) slo hay una forma de distribuir las cuatro entradas en dos conjuntos respetando
el orden, puesto que, M 2m + 2 3 4 + 2 = 1. Para la ordenacin a lo largo del eje X, la
particin resultante sera {(R1, R9), (R2, R3)}. Para la ordenacin a lo largo del eje Y
tendramos la siguiente particin {(R9, R3), (R1, R2)}. Claramente, segn la Figura 2.9.b, la
suma de los permetros de los MBRs de (R1, R9) y de (R2, R3) es menor que la suma de los
permetros de (R9, R3) y de (R1, R2). Por tanto el eje X es el que escogemos como eje de
divisin. Una vez terminado el proceso de divisin, tenemos dos nuevos nodos {R1, R9} y
{R2, R3} que se crearn para reemplazar al nodo original.
Denotemos al MBR de {R1, R9} como R24 y al MBR de {R2, R3} como R25. Las dos
nuevas entradas (R24, P
R24
) y (R25, P
R25
) se crearn para ubicarlas en el nodo raz y
reemplazarlas por la entrada (R21, P
R21
) que aparece en la Figura Fig. 2.7.b. Debido que no
hay suficiente espacio en el nodo raz para contener las cuatro entradas {R24, R25, R22, R23}
se produce un nuevo desbordamiento, pero esta vez a nivel del nodo raz. Debido a que nos
encontramos en el nivel del nodo raz, el proceso de reinsercin ahora no se realiza y en su
lugar llevamos a cabo el proceso de divisin del nodo desbordado (nodo raz). Utilizando el
mismo mtodo que se ha descrito anteriormente a nivel de hoja, llevamos a cabo una particin
a lo largo del eje Y, seleccionando a ste como eje de divisin. Como resultado de este
proceso obtenemos que el nodo raz original se sustituye por dos nuevos nodos {R24, R25} y
{R22, R23}. Denotemos al MBR de {R24, R25} como R26 y al MBR de {R22, R23} como
R27. Por ltimo, se genera un nuevo nodo raz {R26, R27} con sus respectivas entradas (R26,
P
R26
) y (R27, P
R27
), y la altura del rbol se incrementa en 1. El resultado final de la insercin
se muestra en la Figura 2.10, donde en la Figura 2.10.a se ilustran los MBRs y la
correspondiente estructura de archivo para el R*-tree de orden (m, M) = (2, 3) en la Figura
2.10.b (los nodos se corresponden con pginas del archivo en disco).

5
R1 R9 R2 R3 R4 R8
8
2
3
4
7
6
1
23
22
25
X
Y
(0, 0)
R26 R27
9
24
27
26
R5 R6 R7
R24 R25 R22 R23
(a) (b)

Figura 2.10 Distribucin de los MBRs y el R*-tree asociado despus de insertar el MBR R9.



Captulo 2
40
2.6.3.2 Algoritmo de borrado

Para borrar un MBR de un R*-tree se siguen los mismos pasos que para borrarlo de un R-tree
convencional. Primero localizamos el nodo que debera contener a la entrada correspondiente
al MBR y entonces lo borramos si ste est efectivamente en el nodo. Borrar una entrada de
un nodo puede provocar que el nmero de entradas del nodo sea inferior a m (capacidad
mnima del nodo), conocido como underflow. Mejor que redistribuir el nodo con un nmero
menor de m entradas con su hermano como ocurre en un B
+
-tree, dicho nodo se elimina del
R*-tree y las restantes entradas (entradas hurfanas) se reinsertan en el R*-tree. El borrado de
un nodo provoca la eliminacin de una entrada en el nodo padre. El algoritmo de borrado se
disea para eliminar un MBR de cualquier nivel en el R*-tree. Notar que el borrado de una
entrada en un nodo padre puede generar a su vez que ste tenga un nmero de entradas menor
que m (underflow). Este underflow puede propagarse hasta el nodo raz y decrementar en 1 la
altura del R*-tree.
Para presentar el algoritmo de borrado en un R*-tree consideramos los siguientes
parmetros: sea T el puntero al nodo raz del R*-tree, S denota el MBR que va a ser borrado y
L es el nivel donde va a ser borrado el MBR S. Inicialmente, L es el nivel del nodo raz y S es
un MBR que cubre un objeto.
Borrar(S, L, T)
1. Encontrar el nodo en el nivel L que debera contener a S. Esto puede llevarse a cabo
como indicamos a continuacin. Si T apunta a un nodo en el nivel L, entonces
comprobamos cada una de las entradas (R, P) del nodo apuntado por T para determinar
si R contiene a S. Si efectivamente R contiene a S, entonces comprobamos
recursivamente las entradas del nodo hijo apuntados por P (asignando P a T y
decrementando en nivel L en 1).
2. Buscar cada nodo en el nivel L devuelto en el paso 1, si est presente S. Si S no se ha
encontrado en dichos nodos, entonces devolvemos MBR S no encontrado y salimos
del algoritmo. Si encontramos a S en un nodo N, borramos la correspondiente entrada
de N. Si N tiene m o ms entradas despus de borrar S, ajustamos el MBR de N en el
nodo padre de N (N
P
) con todos los MBRs que tiene en ese momento y salimos del
algoritmo. Si N tiene slo m 1 entradas despus de borrar S, tratamos el underflow
como se indica en el paso 3.
3. Tratamiento del underflow (la ocupacin de un nodo est por debajo de m).
3.1. Primero, borramos el nodo N del R*-tree. Esto se lleva a cabo llamando al algoritmo
recursivamente de la siguiente forma: Borrar(S
P
, L
P
, T), donde S
P
es el MBR de N y
L
P
es el nivel del padre con respecto al nivel L. Si el nodo original del padre de N es
el nodo raz y ste tiene un nico nodo hijo despus de borrar el nodo N, hacemos
que dicho nodo hijo sea ahora el nuevo nodo raz.
Mtodos de acceso espaciales basados en MBRs. El R*-tree
41
3.2. Segundo, llamamos a la funcin Insertar(S
i
, P
Si
, L, T) para insertar en el R*-tree cada
una de las m 1 entradas restantes de N (entradas hurfanas), donde cada entrada es
de la forma, (S
i
, P
Si
) para i = 1, 2, ..., m 1.

2.6.3.3 Algoritmo de bsqueda

Cuando queremos realizar consultas que utilizan mtodos de acceso basados en un R*-tree
podemos comprobar que no difieren mucho de las utilizadas para los R-trees convencionales,
como por ejemplo las consultas o bsquedas en rango (tambin denominada consulta de
ventana). Sea S un MBR delimitando un rango, la consulta consiste en encontrar todos los
MBRs de objetos en R*-tree que se solapan (predicado espacial) con S. De forma general, la
consulta empieza desde el nodo raz y calcula todos las entradas de los nodos que se solapan
con S. Sea (R, P) una entrada en un nodo interno N del R*-tree. Si R se solapa tambin con S,
entonces existe la posibilidad de que un MBR de un objeto cubierto por R se solape con S.
Esto significa que el puntero P se debera seguir hasta que los MBRs hijos de R puedan
examinarse con respecto a S. Evidentemente, este proceso debera repetirse para cada una de
las entradas en N cuyos MBRs se solapan con S. Adems, debemos tener en cuenta que al no
existir ningn orden en las entradas que forman el nodo N, tenemos que comparar S con todos
y cada uno de los MBRs que forman el nodo N, para evitar perder MBRs de objetos conforme
vamos descendiendo por el rbol durante el proceso de bsqueda. Es decir, que si algn nodo
en el R*-tree se alcanza durante el proceso de bsqueda, entonces todas las entradas de dicho
nodo deben examinarse.
Para presentar el algoritmo de bsqueda en rango sobre un R*-tree definido en un espacio
bidimensional de datos, debemos considerar los siguientes parmetros: sea T el puntero al
nodo raz del R*-tree y, S denota el MBR definido para la consulta en rango {(x_window
min
,
y_window
min
), (x_window
max
, y_window
max
)}.
Buscar(S, T)
1. Si P
N
es un puntero a un nodo interno, comprobamos cada entrada (R, P) en el nodo
apuntado por P
N
para determinar si R se solapa con S. Los MBRs estn definidos en el
espacio bidimensional. R = {(x
min
, y
min
), (x
max
, y
max
)}, donde (x
min
, y
min
) es el punto del
MBR R situado en la esquina inferior izquierda, y (x
max
, y
max
) es el punto del MBR R
situado en la esquina superior derecha. Y S = {(x_window
min
, y_window
min
),
(x_window
max
, y_window
max
)}, donde (x_window
min
, y_window
min
) es el punto del
MBR S situado en la esquina inferior izquierda, y (x_window
max
, y_window
max
) es el
punto del MBR S situado en la esquina superior derecha. R y S se solapan si se
verifican las siguientes condiciones: x_window
min
x
max
, y_window
min
y
max
,
x_window
max
x
min
e y_window
max
y
min
. Si R se solapa con S, recursivamente
comprobamos todas las entradas en el nodo hijo llamando a la funcin Buscar(S, P).
2. Si P
N
es un puntero a un nodo hoja, comprobamos cada entrada (R, P) en el nodo hoja
apuntado por P
N
para determinar si R se solapa con S. Si R se solapa efectivamente con
Captulo 2
42
S, entonces devolvemos R como un MBR de un objeto que verifica la condicin de
bsqueda en rango (solaparse con S).
En la Figura 2.11 mostramos un ejemplo de bsqueda en rango sobre el conjunto de MBRs
de la Figura 2.7.a, donde el MBR S es el que determina el rango de la consulta en un espacio
bidimensional. El objetivo de la bsqueda es determinar todos los MBRs de objetos que se
solapan con S. Se puede comprobar que el resultado de dicha consulta en rango es {R3, R5 y
R7}.

5
8
2
3
4
7
6
1
23
22
21
X
Y
(0, 0)
S

Figura 2.11 Bsqueda en rango para MBRs de objetos que se solapan con S.

2.6.4 Algoritmos para el procesamiento de consultas utilizando
R*-trees como mtodo de acceso espacial

Despus de introducir a la familia de los mtodos de indexacin R-tree (que han sido
adoptados por sistemas comerciales importantes como Informix [Bro01] y Oracle [Ora01]) y
analizar una de sus variantes (R*-tree), vamos a estudiar los algoritmos asociados a las
consultas espaciales ms importantes utilizando dichos ndices [GaG98].

2.6.4.1 Etapas en el procesamiento de consultas espaciales utilizando R*-
trees

La utilizacin de MBRs como aproximaciones de objetos espaciales proporciona un rpido
pero inexacto filtro para obtener un conjunto respuesta a peticin de una consulta espacial, ya
que el rea que cubre el MBR asociado a un objeto espacial es mayor que el rea del propio
objeto. El conjunto de MBRs candidatos obtenido como resultado de la consulta puede incluir
falsos aciertos, puesto que el MBR de un gran objeto espacial puede solaparse con el MBR de
un objeto espacial pequeo, muy prximo al grande, sin que haya solape entre ellos.
Mtodos de acceso espaciales basados en MBRs. El R*-tree
43
Utilizando los MBRs como aproximacin de los objetos espaciales, en lugar de la
representacin exacta de dichos objetos, los vamos a indexar en un mtodo de acceso espacial
basado en ellos, el R*-tree. Cuando deseemos realizar una consulta que satisfaga un predicado
espacial y devuelva un resultado exacto, se va a tener que procesar la consulta en dos etapas
denominadas: etapa de filtrado y etapa de refinamiento, tal y como se propone en [BKS
+
94].
Dichas etapas se muestran en la Figura 2.12.

Dataset
*

Consulta
MAE
+

Candidatos
Comprobacin con
la geometra exacta
Falsos
Aciertos
Aciertos
Resultado de
la consulta
Fase de Filtrado Fase de Refinamiento
*
Dataset = Conjunto de objetos espaciales
+
MAE = Mtodo de Acceso Espacial

Figura 2.12 Procesamiento de consultas espaciales en dos etapas.
Primera etapa, denominada etapa de filtrado (filter step). En esta fase obtenemos como
resultado de la consulta un conjunto de candidatos (candidate set) que contiene todos los
objetos respuesta y, adems, objetos que no satisfacen el predicado espacial. Despus, para
cada candidato obtenido, si el MBR es suficiente para garantizar que el objeto por s mismo
satisface el predicado espacial, entonces el objeto puede aadirse al resultado final de la
consulta; en caso contrario, los candidatos restantes conforman la entrada para el
procesamiento en la siguiente fase, la etapa de refinamiento. Debemos destacar tambin que
en la etapa de filtrado pueden combinarse varios mtodos de acceso espaciales en base a una
propiedad espacial y no slo uno como se muestra en la grfica, como por ejemplo para
realizar un join espacial entre dos conjuntos de objetos espaciales.
Segunda fase, denominada etapa de refinamiento (refinement step), tambin conocida
como etapa de procesamiento geomtrico exacto. En esta fase tomamos el conjunto de
candidatos de la etapa de filtrado y exploramos si la geometra exacta de estos objetos
satisface el predicado espacial o no. Esta etapa es bastante costosa, ya que debe gestionar la
geometra exacta de los objetos utilizando eficientes algoritmos de geometra computacional
con el objetivo de determinar si estos objetos verifican el predicado espacial. Como resultado
de esta fase podemos obtener dos conjuntos de resultados: (1) Aciertos exactos (hits) que
satisfacen el predicado espacial los cuales se aaden directamente al conjunto solucin final
Captulo 2
44
de la consulta, y (2) Falsos Aciertos (false hits) que no satisfacen el predicado espacial, siendo
automticamente descartados. Es decir, en esta etapa si la evaluacin del predicado espacial es
cierta para la geometra exacta del objeto espacial, entonces aadiremos el objeto al resultado
final de la consulta; en caso contrario, tendremos un falso acierto (false hit) que ser
automticamente descartado.
En los algoritmos que se presenten a continuacin para realizar las consultas espaciales
ms importantes utilizando R*-trees, nos vamos a ocupar slo de los objetos o pares de
objetos candidatos despus de realizar la etapa de filtrado y no profundizaremos en la
segunda etapa (etapa de refinamiento), ya que tendramos que hacer uso de algoritmos
geomtricos para determinar los objetos que pertenecen al conjunto solucin exacto segn un
predicado espacial determinado, y estos algoritmos quedan fuera del alcance de este trabajo
de investigacin.

2.6.4.2 Algoritmos para el procesamiento de consultas espaciales utilizando
R*-trees

En el epgrafe 2.5 se definieron formalmente los tipos de consultas espaciales ms
representativas. En esta seccin, vamos a presentar los algoritmos para realizar dichas
consultas utilizando R*-trees como mtodo de acceso espacial.
Los tipos de consultas espaciales ms importantes son los siguientes:
1. Consulta Exacta (Exact Query). La consulta para la Localizacin de un Punto (Point
Location Query) es un caso particular de Consulta Exacta.
2. Consulta en Rango (Range Query).
3. Consulta del Vecino ms Prximo (Nearest Neighbor Query).
4. Join Espacial (Spatial Join).
La mayora de los algoritmos para realizar consultas espaciales utilizando R*-trees estn
basados en el recorrido recursivo en profundidad del rbol. La idea bsica es leer un nodo del
rbol y realizar la operacin ligada al predicado espacial correspondiente utilizando MBRs a
nivel local.

2.6.4.2.1 Algoritmos para la consulta exacta

Este primer algoritmo determina la consulta exacta para R*-trees, donde los objetos se
encuentran almacenados en un archivo de datos adicional, estando guardado en las hojas del
R*-tree los MBRs de dichos objetos junto con punteros al archivo de datos. Por ello,
Mtodos de acceso espaciales basados en MBRs. El R*-tree
45
necesitamos leer del archivo de datos la geometra exacta del objeto (LeerObjeto) para
compararla con el objeto de consulta, utilizando el predicado espacial igual. El tipo de dato
Objeto es uno de los argumentos del algoritmo, y est formado por dos componentes <MBR,
OBJ>, donde MBR es el mnimo rectngulo que cubre al objeto y OBJ describe la geometra
exacta de dicho objeto.
ConsultaExacta(nP: R_nodo; Obj: Objeto)
01 if nP es un nodo INTERNO then
02 for every entrada p
i
de nP do
03 if cubre(p
i
.MBR, Obj.MBR) then
04 nP = LeerNodo(p
i
.direccion);
05 ConsultaExacta(nP, Obj);
06 endif
07 enddo
08 else
09 for every entrada p
i
de nP do
10 if solapa(p
i
.MBR, Obj.MBR) then
11 Objeto = LeerObjeto(p
i
.direccion);
12 if igual(Objeto, Obj.OBJ) then
13 return true;
14 endif
15 endif
16 enddo
17 endi f
El siguiente algoritmo determina la consulta para la localizacin de un punto. Para este
caso, suponemos que en las hojas estn almacenados los objetos espaciales (puntos), y
utilizamos el predicado espacial igual para compararlos con el punto de consulta p.
ConsultaLocalizacionPunto(nP: R_nodo; p: Punto)
01 if nP es un nodo INTERNO then
02 for every entrada p
i
de nP do
03 if cubre(p
i
.MBR, p) then
04 nP = LeerNodo(p
i
.direccion);
05 ConsultaLocalizacionPunto(nP, p);
06 endif
07 enddo
08 else
09 for every entrada p
i
de nP do
10 if igual(p
i
.MBR, p) then
13 return true;
15 endif
16 enddo
17 endif

2.6.4.2.2 Algoritmos para la consulta en rango

Este primer algoritmo determina la consulta en rango, estando dicho rango definido por el
MBR k-dimensional k_R. El resultado es un conjunto de MBRs almacenados en las hojas del
R*-tree que se solapan con en el rango definido en k_R.
Captulo 2
46
ConsultaRango1(nP: R_nodo; k_R: MBR)
01 if nP es un nodo INTERNO then
02 for every entrada p
i
de nP do
03 if solapa(p
i
.MBR, k_R) then
04 nP = LeerNodo(p
i
.direccion);
05 ConsultaRango1(nP, k_R);
06 endif
07 enddo
08 else
09 for every entrada p
i
de nP do
10 if solapa(p
i
.MBR, k_R) then
11 CR1_Lista.insertar(<p
i
>);
12 endif
13 enddo
14 endif
Otro tipo de consulta en rango es aquella en la que ste viene dado por un punto p y un
intervalo de distancia [Dist_Min, Dist_Max] donde 0 Dist_Min Dist_Max,
determinndose todos los objetos que se solapan con el rango de distancia generado por ellos.
Para desarrollar el algoritmo debemos utilizar la funcin de distancia MINDIST definida en
[RKV95], que obtiene el mnimo valor de distancia entre un punto y un MBR en el espacio
Eucldeo k-dimensional. El algoritmo para determinar esta consulta es el siguiente:
ConsultaRango2(nP: R_nodo; p: Punto; Dist_Min, Dist_Max: Real)
01 if nP es un nodo INTERNO then
02 for every entrada p
i
de nP do
03 if (MINDIST(p, p
i
.MBR) Dist_Max) then
04 nP = LeerNodo(p
i
.direccion);
05 ConsultaRango2(nP, p, Dist_Min, Dist_Max);
06 endif
07 enddo
08 else
09 for every entrada p
i
de nP do
10 dist = DistanciaEuclidea(p, p
i
.MBR);
11 if ((Dist_Min dist) and (dist Dist_Max)) then
12 CR2_Lista.insertar(<p
i
>);
13 endif
14 enddo
15 endif
Si Dist_Min = 0, este tipo de consulta en rango es equivalente a encontrar todos los
vecinos a un punto dado p en el radio de accin determinado por el valor de distancia
Dist_Max, sin establecer un ranking en ellos.

2.6.4.2.3 Algoritmos para la consulta del vecino ms prximo

La consulta para determinar el vecino ms prximo (CVP) o los K vecinos ms prximos (K-
CVP) utilizando estructuras de datos jerrquicas y arbreas es posiblemente la consulta ms
estudiada por los investigadores. [Ben75, FBF77, MuS86, Bro90, Spr91] para k-d-trees,
Mtodos de acceso espaciales basados en MBRs. El R*-tree
47
[HjS95, HoS91] para Quadtrees y sus variantes, y [RKV95, PaM97, ChF98, PaM98, HjS99]
para R-trees son los trabajos ms representativos.
El algoritmo ms conocido es el algoritmo branch-and-bound recursivo propuesto en
[RKV95]. Para encontrar el vecino ms prximo a un objeto dado a priori utilizando R*-trees,
el algoritmo empieza desde la raz del rbol y va descendiendo hasta las hojas. La idea
fundamental del algoritmo es que muchas ramas del rbol pueden ser descartadas siguiendo
unas heursticas de poda basadas en unas mtricas denominadas MINDIST y MINMAXDIST
(slo para el caso que se pretenda encontrar el vecino ms prximo) entre un punto p = (p
1
, p
2
,
..., p
k
) y un MBR definido por dos puntos, k_R, en el espacio Eucldeo k-dimensional.
MINDIST representa el mnimo valor de distancia entre un punto y un MBR, y
MINMAXDIST es la mxima distancia entre un punto y la cara ms prxima de un MBR; las
frmulas para su clculo se vern con mayor detalle en el captulo 3.
El algoritmo que mostramos a continuacin encuentra el vecino ms prximo a un punto
dado, suponiendo que el R*-tree almacena un conjunto de puntos en sus hojas y que T est
inicializado a infinito (T = 8 ). ste tiene como caractersticas que es un algoritmo Recursivo
y No Incremental.
CVP_Recursivo(nP: R_nodo; PuntoConsulta: Punto; VPTemporal: Punto; T: Real)
01 if nP es un nodo INTERNO then
02 Crear_Lista(LISTAMINDIST, nP.numeroDeEntradas);
03 for every entrada p
i
de nP do
04 LISTAMINDIST[i].MinDist = MINDIST(PuntoConsulta, p
i
.MBR);
05 MinMaxDist = MINMAXDIST(PuntoConsulta, p
i
.MBR);
06 if MinMaxDist < T then
07 T = MinMaxDist;
08 endif
09 LISTAMINDIST[i].direccion = p
i
.direccion;
10 enddo
11 Ordenar_Lista(LISTAMINDIST, 0, (nP.numeroDeEntradas 1));
12 t = 0;
13 while ((LISTAMINDIST[t].MinDist T) and (t < nP.numeroDeEntradas)) do
14 M = LeerNodo(LISTAMINDIST[t].direccion);
15 CVP_Recursivo(M, PuntoConsulta, VPTemporal, T);
16 t = t +1;
17 enddo
18 Destruir_Lista(LISTAMINDIST);
19 else
20 for every entrada p
i
de nP do
21 dist = DistanciaEuclidea(PuntoConsulta, p
i
.MBR);
22 if dist T then
23 T = dist;
24 VPTemporal = p
i
;
25 endif
26 enddo
27 endif
Para procesar el caso general del vecino ms prximo (obtener los K vecinos ms
prximos) debemos mantener una estructura de datos adicional en la que estn almacenados
los K vecinos ms prximos procesados hasta el momento. El mecanismo de poda de MBRs
no se realiza utilizando MinMaxDist como sucede para el caso del vecino ms prximo, sino
que se debe llevar a cabo segn la distancia del elemento ms lejano de los vecinos ms
Captulo 2
48
prximos almacenados hasta el momento en la estructura de datos auxiliar (es decir, el K-
simo vecino ms prximo encontrado hasta el momento). Es importante destacar que la
estructura de datos que se utiliza es un montculo (heap) de elementos en el que la distancia
mayor es la del elemento situado en la raz (montculo mximo). Al principio todos los
elementos del montculo adicional deben estar inicializados a .
En [HjS99] presentan un algoritmo general basado en [HjS95] para encontrar el vecino
ms prximo de una forma incremental e iterativa utilizando R-trees. Este algoritmo es
incremental en el sentido de que habiendo obtenido los K vecinos ms prximos, el (K + 1)-
simo vecino puede obtenerse sin tener que calcular desde el principio los K + 1 vecinos ms
prximos. Adems, el usuario obtiene parte del resultado antes de la finalizacin del
algoritmo, pudiendo detener ste en el momento que considere oportuno.
La versin incremental e iterativa para encontrar el vecino ms prximo decide qu nodo
va a procesar a continuacin, escogiendo de una estructura de datos auxiliar donde se
almacenan todos los nodos que han sido visitados hasta el momento, el nodo con menor
distancia. Esta forma de gestionar los datos nos lleva a utilizar, como estructura de datos
global, una cola de prioridad (implementada como un montculo) donde la distancia entre el
punto de consulta y los elementos del R-tree se utiliza como clave, y adems aquel elemento
del R-tree con menor distancia al punto de consulta est ubicado al principio de la cola de
prioridad. Debemos destacar que en la cola de prioridad se almacenan todos los posibles
elementos del R-tree (puntos y MBRs). Es claro que gestionar de una forma controlada el
recorrido del rbol, evita tener que deshacer la recursividad en la fase de backtracking (ahorro
en tiempo de respuesta) y recorrer caminos innecesarios (accesos a disco). En [HjS99,
BBK
+
97] se demuestra que este algoritmo es ptimo, en el sentido de que minimiza el nmero
de nodos a procesar.
El algoritmo que mostramos a continuacin encuentra el vecino ms prximo a un punto
dado, suponiendo que el R*-tree almacena puntos en sus hojas. ste tiene como caracterstica
que es un algoritmo Iterativo e Incremental.
CVP_Incremental(Raz: R_nodo; PuntoConsulta: Punto)
01 M = crearMonticulo();
02 T = 8 ;
03 VP_retornados = 0;
04 M.insertarElemento(0.0, Raiz.direccion, altura 1, Raiz.MBR);
05 while ((VP_retornados < 1) and (not M.estaVacio())) do
06 Elem = M.eliminarMinimo();
07 if Elem.level_nP == 0 then
08 CVP = Elem;
09 VP_retornados = VP_retornados + 1;
10 else
11 nP = LeerNodo(Elem.direccin_nP);
12 if nP es un nodo HOJA then
13 for every entrada p
i
de nP do
14 dist = DistanciaEuclidea(PuntoConsulta, p
i
.MBR);
15 if dist T then
16 T = dist;
17 M.insertarElemento(dis t, p
i
.direccion, p
i
.nivel, p
i
.MBR);
18 endif
19 enddo
20 else
Mtodos de acceso espaciales basados en MBRs. El R*-tree
49
21 for every entrada p
i
de nP do
22 MinMaxDist = MINMAXDIST(PuntoConsulta, p
i
.MBR);
23 if MinMaxDist < T then
24 T = MinMaxDist;
25 endif
26 enddo
27 for every entrada p
i
de nP do
28 if MINDIST(PuntoConsulta, p
i
.MBR) T then
29 M.insertarElemento(MINDIST(PuntoConsulta, p
i
.MBR), p
i
.direccion, p
i
.nivel, p
i
.MBR);
30 endif
31 enddo
32 endif
33 endif
34 enddo
35 M.destruirMonticulo();
36 return CVP;
Debemos destacar que en la lnea 5 del algoritmo CVP_Incremental se ha colocado la
condicin VP_retornados < 1 con el objetivo de devolver como resultado slo el vecino ms
prximo. La extensin de este algoritmo para encontrar los K vecinos ms prximos es
sencilla, ya que las nicas modificaciones que se deben hacer son: (1) no utilizar la mtrica
MINMAXDIST cuando se estn procesando MBRs del R-tree en el rango de lneas 21-26, (2)
aplicar la condicin VP_retornados < K, y (3) insertar en la cola de prioridad todos los
posibles elementos del R-tree (puntos y MBRs) sin considerar el mecanismo de poda con la
variable T en las lneas 15 y 28, junto con la inicializacin y actualizacin de T en las lneas 2,
16 y24.
Existe una importante diferencia entre los algoritmos iterativos incrementales y no
incrementales. Los algoritmos iterativos e incrementales devuelven los objetos ms prximos
al punto dado, uno a uno (si devuelve al K-simo vecino ms prximo, para obtener en (K +
1)-simo no es necesario comenzar la consulta desde el principio). Para ello se debe
almacenar en la cola de prioridad todos los posibles elementos del R*-tree (MBRs y Puntos o
MBRs de los objetos). Por el contrario, los algoritmos iterativos y no incrementales, solo
insertan en el montculo principal los MBRs del R*-tree, procesando en las hojas todos los
puntos o MBRs de los objetos, y se insertan en un montculo mximo adicional de tamao K
los que tienen una distancia mnima menor que la distancia del elemento ubicado en la raz
del montculo. Cabe destacar que la suma de elementos insertados en los dos montculos
(principal y adicional) del algoritmo no incremental es menor que los almacenados en la cola
de prioridad del algoritmo incremental, ya que en este ltimo se insertan elementos que en el
futuro puede que no se utilicen en beneficio del procesado incremental.

2.6.4.2.4 Algoritmos para determinar el join espacial

Hemos visto en el epgrafe 2.5 la definicin del join espacial (JE) en la que, dados dos
conjuntos de objetos espaciales P y Q, y un predicado espacial , se determinan todos los
pares de objetos espaciales (O, O) P Q, donde la evaluacin del predicado espacial
(O.geo, O.geo) es cierta.
Captulo 2
50
JE(P, Q, ) = {(O, O) PQ : (O.geo, O.geo)}
Para el predicado espacial existe una amplia gama de posibilidades. El join espacial es
una operacin definida sobre dos conjuntos de objetos espaciales y calcula el subconjunto del
producto cartesiano de dichos conjuntos bajo un determinado predicado espacial.
En [PRS99] se hace una clasificacin del Join Espacial en tres categoras dependiendo de
si cada conjunto de objetos espaciales que interviene en la consulta est indexado o no:
Sin ndices. Para el caso en los que no existe ningn ndice sobre los conjuntos de objetos
espaciales se han propuesto varias tcnicas de divisin del espacio en cubetas (buckets) y
despus aplicar tcnicas dispersin (hashing) o lnea de barrido (sweep-line), [ArS94, GS89,
KoS97, LoR96, PaD96]. En este caso, ambos conjuntos de datos de entrada tienen que ser
preprocesados en orden para facilitar el procesamiento del join. En [APR
+
98] se propone un
algoritmo denominado join espacial basado en un barrido escalable (scalable sweeping-
based spatial join) que emplea una combinacin del Barrido del Plano [PrS85] y la divisin
del espacio para realizar el join, trabajando bajo la suposicin de que en la mayora de los
casos el final de la lnea de barrido puede almacenarse en memoria principal. Sin embargo, el
algoritmo no puede evitar la ordenacin externa de ambos conjuntos de datos, lo cual puede
generar una gran sobrecarga de operaciones de E/S (nmero de accesos a disco). En [PaD96]
se describe un algoritmo para el join por dispersin (hash join), denominado join espacial por
mezcla basado en particiones (partition based spatial merge join), que divide el espacio de
forma regular utilizando una rejilla rectangular, y distribuye ambas entradas en dichas
particiones del espacio. Entonces combina grupos de particiones que cubre la misma rea
utilizando la tcnica de Barrido del Plano para generar el resultado del join. Algunos objetos
de ambos conjuntos de datos de entrada pueden asignarse en ms de una particin. Por ello, el
algoritmo necesita ordenar el resultado para eliminar pares duplicados. Otro algoritmo basado
en la descomposicin regular del espacio es el join espacial por separacin de tamao (size
separation spatial join) [KoS97], que evita la duplicidad de objetos durante la fase de
particin, introduciendo ms de un nivel de particin. Cada objeto es asignado a una nica
particin, pero una particin puede ser enlazada con varios niveles superiores. Normalmente,
el nmero de niveles es lo suficientemente pequeo para que una particin de cada nivel
pueda almacenarse en memoria, por tanto, no se necesitan muchas pasadas durante el
procesamiento del join. Por ltimo, el join espacial por dispersin (spatial hash join) [LoR96]
evita resultados duplicados ejecutando una descomposicin del espacio irregular, basada en la
distribucin de los datos de entrada.
Dos ndices. Cuando tenemos dos conjuntos de objetos indexados, los algoritmos que han
sido presentados dependen del mtodo de indexacin utilizado. [Ore86] es el primer trabajo
conocido sobre join espacial, proponiendo un orden 1-dimensional de objetos espaciales
cuyos cdigos son indexados dinmicamente en un B
+
-tree y combinados en funcin de un
predicado espacial, siguiendo un esquema de join en ordenacin y mezcla (sort-merge join).
Este esquema utiliza una rejilla para dividir de forma regular el espacio multidimensional en
bloques pequeos, denominados pixels, y utiliza una curva de llenado del espacio (z-ordering)
para ordenarlos. Las aproximaciones de los objetos son un conjunto de pixels que se solapan
con su MBR, es decir, un conjunto de z-valores (z-values). Debido a que los z-valores son 1-
dimensionales, los objetos pueden indexarse de forma dinmica utilizando estructuras de
ndice unidimensionales, como el B
+
-tree, y el join espacial se ejecuta siguiendo un esquema
de ordenacin y mezcla (sort-merge join). El rendimiento del algoritmo depende de la
Mtodos de acceso espaciales basados en MBRs. El R*-tree
51
granularidad de la rejilla, ya que rejillas con mucha precisin pueden proporcionar
aproximaciones de objetos muy buenas, aunque los requerimientos de espacio se incrementan.
En [Rot91] se propone un algoritmo basado en un join espacial indexado (spatial join index),
similar al join relacional indexado de [Val87], que precalcula parcialmente el resultado del
join y utiliza Grid Files para indexar los objetos en el espacio. [Gn93] fue el primer trabajo
propuesto siguiendo una estrategia denominada recorrido sincronizado de los rboles
(synchronized tree traversal), el cual puede ser perfectamente adaptable a una gran familia de
mtodos de acceso espaciales y de predicados espaciales. El algoritmo de [BKS93a] es el ms
popular de los que realizan un recorrido sincronizado de los rboles en profundidad para el
predicado espacial solapa utilizando R*-trees, por su eficiencia. Adems, introduce una serie
de tcnicas avanzadas sobre el algoritmo, aplicadas de forma local para reducir y optimizar
los costes de CPU (Barrido del Plano) y nmero de accesos a disco (restriccin del espacio de
bsqueda). En [HJR97a] se propone un algoritmo para realizar un join espacial denominado
Breadth-First R-tree Join (BFRJ) que recorre los dos rboles de forma sncrona siguiendo una
poltica de recorrido en anchura, donde es necesario procesar todos los pares de un nivel antes
de procesar los pares de niveles ms bajos. En cada nivel, BFRJ genera un resultado
intermedio del join y utiliza tcnicas de optimizacin global (ordenacin, gestin de memoria
y gestin del buffer) para mejorar el clculo del join en el siguiente nivel. En [HjS98] se
introduce un nuevo tipo de Join Espacial Basado en Distancias cuyo conjunto solucin de
pares ordenados se obtiene de forma incremental e iterativa. Se plantean tres variantes del
algoritmo incremental e iterativo (Basic, Evenly y Simultaneous) segn la poltica con que se
recorran los R*-trees. En [SML00] se presentan varias mejoras al algoritmo original de
[HjS98]. Tambin debemos indicar que en [HoS95] se presenta un mtodo similar al recorrido
sincronizado en los dos rboles para realizar el join entre PMR quadtrees.
Un nico ndice. Cuando existe un nico ndice y el otro conjunto de objetos que
interviene en la relacin no est indexado, la estrategia ms sencilla es la de examinar y actuar
sobre el ndice (scan and index), donde se examina el conjunto de objetos espaciales no
indexados y para cada objeto espacial O de dicho conjunto aplicamos una consulta en rango
con argumento O.MBR segn el predicado espacial sobre el conjunto de objetos indexados.
La gran eficiencia mostrada por los algoritmos que siguen un recorrido sincronizado del rbol,
sugiere la construccin de un segundo ndice ligado al conjunto de objetos espaciales no
indexado. Basndose en esta idea, surgi el join espacial que construye un seeded-tree
[LoR94, LoR95, LoR98] sobre el conjunto de objetos espaciales no indexados, el cual es un
R-tree cuyos primeros niveles coinciden exactamente con aquellos del R-tree existente. Otra
aproximacin denominada construir y emparejar (build and match) [PaD96], consiste en
construir un R-tree compacto para el conjunto de objetos no indexado utilizando carga masiva
(bulk loading) y entonces realizar un join entre los dos R-trees para combinar los dos rboles.
Por ltimo, el algoritmo denominado ordenar y emparejar (sort and match), propuesto en
[PRS99], ordena espacialmente los objetos no indexados, pero en lugar de construir un rbol
compacto (packed tree), ste empareja cada objeto ordenado en memoria con los nodos hoja
del rbol existente que se solapan con l.
La siguiente tabla resume los algoritmos para el join espacial presentados hasta el
momento, clasificados segn estn o no indexados los conjuntos de datos que intervienen en
la consulta.


Captulo 2
52
Ambas entradas estn indexadas Una entrada est indexada Ninguna entrada est indexada
Transformacin a z-valores [Ore86] Examinar + Consulta en Rango Join espacial por dispersin
[LoR96]
Join espacial indexado [Rot91] Join con seeded-tree [LoR94,
LoR98]
Join espacial por mezcla basado en
particiones [PaD96]
Join espacial combinando los dos
rboles [Gn93, BKS93a, HoS95,
HJR97a, HjS98, SML00]
Construir y emparejar [PaD96] Join espacial por separacin de
tamao [KoS97]
Ordenar y emparejar [PRS99] Join espacial basado en un barrido
escalable [APR
+
98]
Tabla 2.3 Clasificacin de los mtodos de join espacial.
En general, la indexacin hace ms eficiente el procesamiento del join espacial, un
algoritmo que utiliza ndices se espera que sea ms eficiente que uno que no los considere. El
rendimiento relativo dentro de la misma clase depende de las caractersticas del problema. En
[Gt93], se sugiere que el join espacial indexado (spatial join index) [Rot91] es la mejor
alternativa cuando hay baja selectividad en el join, mientras que el recorrido sincronizado de
los dos rboles es la mejor alternativa en los otros casos. Entre los esquemas que utilizan un
solo ndice, el algoritmo propuesto en [PRS99] puede ser considerado mejor que los otros
mtodos, puesto que evita la construccin de un R-tree. Para los algoritmos que no utilizan
ningn ndice no existe una evaluacin experimental concluyente. Cada uno de los algoritmos
posee ciertas ventajas respecto de los otros que lo hacen ms apropiado en determinadas
situaciones. Por ejemplo, el algoritmo presentado en [PaD96] es el ms apropiado para el
procesamiento de mltiples joins en paralelo, ya que utiliza particiones con extensiones fijas.
Nosotros nos centraremos en los algoritmos ms importantes para el join espacial en el que
los dos conjuntos de objetos estn indexados (segunda categora), utilizando R*-trees. En
[BKS93a] se presenta una tcnica para realizar el join espacial siguiendo un recorrido
sincronizado en profundidad sobre los dos R*-trees. La idea bsica es leer dos nodos, uno de
cada rbol, y realizar la operacin de join con el predicado espacial solapa de los MBRs que
pertenecen a cada nodo. El esquema general es el siguiente: sean nP y nQ dos nodos de un
nivel cualquiera del los R*-trees R
P
y R
Q
que indexan los conjuntos de objetos P y Q,
respectivamente El algoritmo realiza la combinacin entre las entradas de los dos nodos nP y
nQ, devuelve como resultado un conjunto de pares <p
i
, q
j
> que verifiquen el predicado
espacial solapa tal que p
i
.MBR q
j
.MBR . La primera aproximacin del algoritmo que
se propone en [BKS93a] es la siguiente:
JoinEspacial(nP: R_nodo; nQ: R_nodo)
01 for every entrada p
i
de nP do
02 for every entrada q
j
de nQ; tal que p
i
.MBR q
j
.MBR do
03 if nP es un nodo HOJA then
04 JE_Lista.insertar(<p
i
, q
j
>);
05 else
06 nP = LeerNodo(p
i
.direccion);
07 nQ = LeerNodo(q
i
.direccion);
08 JoinEspacial(nP, nQ);
09 endif
10 enddo
11 enddo
Mtodos de acceso espaciales basados en MBRs. El R*-tree
53
En [BKS93a] se presentan tambin dos tcnicas de optimizacin local con el objetivo de
reducir el tiempo de CPU y el nmero de accesos a disco (operaciones de E/S) sobre dicha
consulta. Las tcnicas son denominadas: restriccin del espacio de bsqueda y Barrido del
Plano [PrS88].
Restriccin del espacio de bsqueda. Durante el procesamiento del join entre los dos
nodos nP y nQ, si el rea de solape entre los MBRs de esos dos nodos es no vaca (nP.MBR
nQ.MBR ), entonces ese rea es en s un MBR (denominado MBR-solape). El
procesamiento en lneas generales es el siguiente: si una entrada <p
i
.direccion, p
i
.MBR>
x
en
nP se solapa con una entrada <q
j
.direccion, q
j
.MBR>
y
en nQ (p
i
.MBR
x
q
j
.MBR
y
),
entonces ambos MBRs deben solaparse con el MBR-solape. Por tanto, podemos examinar
todas las entradas en nP y nQ una vez, para descartar las entradas cuyos MBRs no se solapan
con el MBR-solape entre los dos nodos.
Barrido del Plano (plane-sweep). Esta optimizacin es similar a la tcnica del join por
ordenacin-mezcla (sort-merge join) utilizado para realizar el join entre dos conjuntos de
objetos. Esta optimizacin se utiliza en este algoritmo en lugar de un bucle anidado para
realizar el join entre entradas de dos nodos (todos con todos). El proceso de optimizacin
utilizando la tcnica de Barrido del Plano (plane sweep) sobre el join de dos nodos nP y nQ
se lleva a cabo en dos etapas. Primero, se ordenan los MBRs de los dos nodos respecto a su
coordenada X (p
i
.MBR
x
y q
j
.MBR
x
), respectivamente. Y segundo, en el proceso de mezcla, se
examinan los MBR de los dos nodos ordenados segn su coordenada X de forma secuencial,
y para cada MBR (por ejemplo, p
i
.MBR
x
) se comprueba el solape con los MBRs de las
entradas del otro nodo segn su coordenada X (q
j
.MBR
x
).
En [HJR97a] se propone un algoritmo para realizar un join espacial denominado Breadth-
First R-tree Join (BFRJ) que recorre los dos rboles de forma sincronizada siguiendo una
poltica de recorrido en anchura. La idea en la que se basa este algoritmo es en la propiedad de
los MBR en un R-tree, en la que el MBR de un nodo siempre cubre a los MBRs de sus nodos
descendientes en niveles inferiores. Teniendo en cuenta esta propiedad, el join entre nP y nQ
slo es necesario cuando el MBR del nodo padre de nP se solapa con el MBR del nodo padre
de nQ. En [BKS93a] la eliminacin de candidatos se realiza recorriendo los dos rboles de
manera sncrona en profundidad, mientras que en BFRJ los dos rboles se recorren en
anchura. El esquema del algoritmo propuesto en [HJR97a] es el que se muestra a continuacin
destacando que R
P
y R
Q
son dos R*-tress (indexan a los conjuntos de objetos P y Q,
respectivamente) con la misma altura hP y hQ, IJI[i] (Intermediate Join Indexes) es la
estructura intermedia del join entre ndices en el nivel i (conjunto de pares <p
i
, q
i
> candidatos
en el nivel i), y <p
i
.direccion, q
i
.direccion> IJI[i].
BFRJ(RaizP, RaizQ: R_nodo)
01 IJI[hP] = ;
02 IJI[0] = Node_Pair_Join(<RaizP.direccion, RaizQ.direccion>); i = 0;
03 while (i < (hP 1)) do
04 while (IJI[i] ) do
05 tempIJI[i] = Node_Pair_Join(<p
i
.direccion, q
i
.direccion>);
06 IJI[i + 1] = IJI[i + 1] tempIJI[i];
07 enddo
08 i = i + 1;
09 enddo
10 output IJI[i];
Captulo 2
54
Debemos destacar que la funcin Node_Pair_Join(<p
i
.direccion, q
i
.direccion>) lee del
disco los nodos apuntados por p
i
.direccion y q
i
.direccion e inserta en un conjunto temporal,
tempIJI[i], todos los pares <p
i+1
, q
i+1
> que satisfacen el predicado espacial solapa.
En cada nivel, BFRJ genera un resultado intermedio del join en el nivel i despus de que
todos los nodos de R
P
en el nivel i han sido relacionados mediante el predicado espacial
solapa con todos los nodos de R
Q
en el mismo nivel. La seleccin de los nodos de R
P
y R
Q

para realizar el join en el nivel i se basa en los pares de elementos que hay actualmente en la
estructura intermedia del join entre ndices en el nivel i 1, IJI[i 1]. Por ello, para obtener el
mayor rendimiento del algoritmo, BFRJ utiliza tcnicas de optimizacin global sobre la
estructura IJI como son: ordenacin, gestin de memoria y gestin del buffer.
Ordenacin de la estructura intermedia del join entre los ndices. Como en IJI[i] hay
pares de la forma <p
i
, q
i
> en el nivel i, procedentes de los R*-trees de R
P
y R
Q
. El objetivo es
mantener dichos elementos siguiendo un orden. En [HJR97a] se proponen 5 polticas de
ordenacin: (1) No aplicar ningn tipo de ordenacin (OrdNon). (2) Ordenar los elementos de
uno de los R*-trees (OrdOne), que consiste en ordenar los elementos p
i
del R*-tree de P (R
P
)
segn los valores de la coordenada del eje X. (3) Ordenar segn la suma de los centros
(OrdSum), calculando el centro de los MBRs de p
i
y q
i
segn los valores de sus coordenadas
del eje X y despus suma dichos valores para obtener el valor a ordenar. (4) Ordenar segn el
punto central del MBR envolvente (OrdCen), para desarrollar esta estrategia de ordenacin
primero genera el MBR que envuelve a p
i
.MBR y q
i
.MBR calculando posteriormente el
centro segn los valores del eje X del MBR envolvente. (5) Ordenar por el valor de la curva
de Hilbert del centro del MBR envolvente (OrdHil), para ello calcula el valor de la curva de
Hilbert para el punto central del MBR envolvente, y ordena el IJI[i] segn dichos valores.
Gestin de la estructura intermedia del join entre ndices (IJI). Debido a que la
estructura IJI puede almacenarse en memoria o en disco, se puede hacer la ordenacin de la
misma tanto en memoria (OrdMem) como en disco (OrdDis) con el objetivo de minimizar el
nmero de operaciones de E/S (accesos a disco).
Gestin del buffer de la estructura intermedia del join entre ndices. Esta ltima
estrategia de optimizacin global est basada en la implementacin de un gestor del buffer
bajo una extensin de la poltica de reemplazo de pgina LRU. Dicho gestor implementa las
operaciones bsicas para la manipulacin de pginas en el buffer que denomina pin (marca la
pgina para retenerla en el buffer LRU hasta que se realiza una operacin upin), upin (elimina
la marca pin) y purge (elimina una pgina del buffer LRU y la inserta en una l ista de pginas
libres).
La diferencia ms significativa entre BFRJ (recorrido sincronizado en anchura) y el
presentado en [BKS93a] (recorrido sincronizado en profundidad) es que BFRJ nunca
retrocede en su recorrido de los rboles, mientras que la otra alternativa retrocede en el
recorrido sincronizado de los rboles debido al procesamiento recursivo del mismo (fase de
backtracking). Por tanto, en BFRJ si no se realiza una optimizacin global de la estructura
intermedia del join entre ndices, IJI, cuando se procesa el join en un mismo nivel, entonces
habr accesos a discos redundantes de la misma pgina. Mientras que en el algoritmo que
sigue un recorrido sincronizado en profundidad, estos accesos redundantes ocurren en la fase
de backtracking.
Mtodos de acceso espaciales basados en MBRs. El R*-tree
55
En [HjS98] se presentan tres variantes (Basic, Evenly y Simultaneous) de un algoritmo
incremental e iterativo para resolver el Join Basado en Distancias (una aplicacin de esta
operacin es encontrar los pares ms cercanos). Debido a que es un join basado en distancias,
ste calcula un subconjunto del producto cartesiano de dos conjuntos de objetos espaciales en
el espacio Eucldeo k-dimensional, y especifica un orden (en ranking) sobre los elementos del
conjunto final basado en la distancia Eucldea. Dicho algoritmo es iterativo puesto que utiliza
una cola de prioridad (implementada como un montculo) para evitar la recursividad, y es
incremental, ya que devuelve los pares uno a uno en orden ascendente de distancia, pudiendo
detener la consulta en cualquier momento y luego continuar sin tener que volver a ejecutarla
desde el principio (caracterstica de los algoritmos no incrementales). En general, el
mecanismo para calcular esta consulta es como aplicar de forma simultnea al algoritmo
incremental del vecino ms prximo presentado en [HjS95], a dos estructuras de datos
arbreas multidimensionales.
En [HjS98] tambin se presentan variantes de los mismos para realizar la operacin de
Semi-Join Basado en Distancias, en el sentido de que el resultado de dicha operacin es un
subconjunto del Join Basado en Distancias, donde un par de objetos espaciales <p
i
, q
i
>
aparece en el conjunto resultado slo si ninguno de los restantes pares tiene como primer
componente a p
i
. Es decir, que en el conjunto resultado para esta operacin van a estar
formado por todos los pares <p
i
, q
i
> donde cada objeto p
i
P est ligado con el objeto ms
cercano q
i
Q. Evidentemente, la cardinalidad del conjunto resultado para el Semi-Join
Basado en Distancias ser P. Un ejemplo para esta consulta sera determinar los pares
(tienda, almacn), tal que una vez encontrado el almacn ms cercano a una tienda, dicha
tienda ya no interviene ms en otros pares con los restantes almacenes.
La entrada del algoritmo para realizar el Join Basado en Distancias presentado en [HjS98]
est formado por dos ndices espaciales R
P
y R
Q
. Dicho algoritmo mantiene un conjunto de
pares M, con un elemento de R
P
y otro de R
Q
, pudiendo ser cada elemento un MBR (nodo
interno) o un objeto (si est almacenado en los nodos hoja). Inicialmente, M contiene un par
con las direcciones de los nodos raz de R
P
y R
Q
. El conjunto de todos los pares (producto
cartesiano de todos los elementos de R
P
y R
Q
) se obtiene de la siguiente forma. Durante todo
el proceso M contiene pares p de elementos de la forma (MBR/MBR, MBR/OBJ, OBJ/MBR y
OBJ/OBJ), despus p se reemplaza por todos los pares resultantes de sustituir el/los MBRs
por todas las combinaciones de pares de entradas de sus nodos hijo (todos los MBRs para los
nodos internos y los objetos o MBRs de objetos para los nodos hoja). Este proceso tan
intuitivo dar como resultado que en M estn todos los posibles pares de elementos (producto
cartesiano) que se pueden formar de R
P
y R
Q
. El algoritmo esencialmente calcula M de la
forma anteriormente descrita, con la restriccin de que los pares se organizan segn sus
mnimas distancias como una cola de prioridad, intentando devolver los pares de objetos con
menor distancia tan pronto como sea posible.
En cada paso de la variante bsica (Basic) del algoritmo, se extrae el par que est al
principio de la cola de prioridad, es decir, el par con la mnima distancia. Si el elemento que
est al principio de la cola de prioridad almacena un par de objetos <o
1
, o
2
>, entonces dicho
par es devuelto como el siguiente par ms cercano. Debido al funcionamiento del algoritmo y
a la forma de gestionar los elementos almacenados en la cola de prioridad, ningn par de
objetos que se devuelva posteriormente tendr una mnima distancia menor que la del ltimo
par de objetos devuelto. Adems, por las restricciones de consistencia de las funciones de
Captulo 2
56
distancia (d(MBR
1
, OBJ
2
) d(OBJ
1
, OBJ
2
), por la definicin de MBR) se garantiza que
ningn par en la cola de prioridad dar lugar a un par de objetos con una distancia
estrictamente ms pequea. Si uno de los miembros del par que ha devuelto el algoritmo es un
MBR, entonces ste inserta en la cola de prioridad todas las posibles entradas del nodo hijo
apuntado por dicho MBR que se pueden generar junto con el otro miembro del par. A
continuacin, se presenta el algoritmo en su variante bsica (Basic).
JoinDistancia(RaizP, RaizQ: R_nodo)
01 M = crearMonticulo();
02 M.insertarElemento(0, <RaizP.direccion, RaizQ.direccion>);
03 while not M.estaVacio() do
04 Elem = M.eliminarMinimo();
05 if ambos componente del par en Elem son objetos then
06 return Elem;
07 else if ambos componente del par en Elem son MBRs de objetos ([RP] y [RQ]) then
08 objRP = referencia real al objeto limitado por el [RP];
09 objRQ = referencia real al objeto limitado por el [RQ];
10 D = MinimaDistancia(objRP, objRQ);
11 if M.estaVacio() or D M.encontrarMinimaDistancia() then
12 return < objRP, objRQ>;
13 else
14 M.insertarElemento(D, <objRP, objRQ>);
15 endif
16 else if el primer componente del par en Elem es un MBR then
17 PROCESARNODO_RP(Elem);
18 else
19 PROCESARNODO_RQ(Elem);
20 endif
21 enddo
22 M.destruirMonticulo();
PROCESARNODO_RP(Elem: Heap_Elemento)
01 NodeP = Primer componente de Elem;
02 ItemQ = Segundo componente de Elem;
03 if NodeP es un nodo INTERNO then
04 for every [RP] en NodeP do
05 M.insertarElemento(MinimaDistancia([RP], ItemQ), <[RP], ItemQ>);
06 enddo
07 else
08 for every MBR en NodeP do
09 M.insertarElemento(MinimaDistancia(MBR, ItemQ), <MBR, ItemQ>);
10 enddo
11 endif
PROCESARNODO_RQ(Elem: Heap_Elemento)
01 ItemP = primer componente de Elem;
02 NodeQ = Segundo componente de Elem;
03 if NodeQ es un nodo INTERNO then
04 for every [RQ] en NodeQ do
05 M.insertarElemento(MinimaDistancia(ItemP, [RQ]), <ItemP, [RQ]>);
06 enddo
07 else
08 for every MBR en NodeQ do
09 M.insertarElemento(MinimaDistancia(ItemP, MBR), <ItemP, MBR>);
10 enddo
11 endif
Mtodos de acceso espaciales basados en MBRs. El R*-tree
57
Las tres variantes del algoritmo que se presentan en [HjS98] se clasifican en funcin de la
poltica con que recorren los R*-trees. Si la prioridad se le da arbitrariamente a uno de los dos
R*-trees (por ejemplo, a R
P
) tenemos el algoritmo Basic. Si la prioridad es dada al
componente del par con menor profundidad obtenemos la variante Evenly (si ambos
elementos en el par tienen el mismo nivel de profundidad en sus respectivos R*-trees,
entonces esta variante escoge para procesar el componente del par cuyo MBR tiene mayor
rea). Y si todos los posibles pares de elementos generados son candidatos para el recorrido
de los rboles, surge la alternativa Simultaneous.
En [HjS98] se presentan tambin extensiones del algoritmo para determinar los K pares
ms cercanos (siendo en este caso incremental hasta K) y Semi-Join Basado en Distancias.
Para llevar a cabo la primera extensin utiliza la mxima distancia de los elementos que
componen un par, junto con estructuras de datos adicionales (cola de prioridad en la que la
principio est el mximo valor y tabla hash). Para la segunda de las extensiones presenta seis
aproximaciones para realizar dicha operacin, junto con estructuras de datos adicionales para
almacenar elementos de uno de los R*-trees (objetos y MBRs o slo objetos).
En [SML00] se presentan mejoras a [HjS98] utilizando la tcnica de Barrido del Plano
junto con un esquema multietapa basado en montculos adicionales para obtener el conjunto
solucin del Join Basado en Distancias de manera incremental e iterativa. En este trabajo
demostraron empricamente mejorar considerablemente los resultados presentados en [HjS98]
respecto al nmero de accesos a disco, clculo de distancias y tiempo de respuesta.
Para finalizar con esta revisin de los algoritmos ms representativos que realizan la
operacin join, debemos citar el trabajo [CVM99], donde se presenta un join entre dos
estructuras de datos espaciales diferentes como son R*-trees [BKS
+
90] y Linear Region
Quadtrees [FiB74, Sam90a, Sam90b, Gar82, Abe84] almacenados en B
+
-trees, ya que ambas
pueden coexistir en un sistema de base de datos espacial. Para llevar a cabo esta operacin se
utilizan heursticas y un esquema de buffering complejo, tratando de reducir al mximo el
nmero de accesos a disco. Antes de empezar con el procesamiento del algoritmo, es
necesario realizar una normalizacin de los espacios que cubren los dos mtodos de acceso
que intervienen en la consulta.

2.7 Conclusiones

En el presente captulo hemos estudiado los mtodos de acceso espaciales basados en MBRs,
prestando especial atencin al R*-tree. Para ello, hemos revisado y clasificado los mtodos de
acceso multidimensionales ms conocidos. A continuacin, se ha estudiado el modelo de
organizacin de ndices basados en MBRs en un espacio de datos multidimensional, que es la
base para el diseo de algoritmos de creacin mtodos de indexacin pertenecientes a la
familia de los R-tree k-dimensionales.
El R*-tree, como mtodo de acceso espacial basado en MBRs y perteneciente a la familia
de los R-tree k-dimensionales, aade fundamentalmente dos mejoras al R-tree convencional
cuando sucede el desbordamiento de un nodo en el algoritmo de insercin. La primera, en
Captulo 2
58
lugar de considerar el rea, el algoritmo de divisin del R*-tree intenta minimizar el permetro
y el solape de los MBRs expandidos de un nodo. Al minimizarse el solape, se reduce el
nmero de subrboles a explorar para las operaciones de bsqueda. La segunda mejora
consiste en introducir el concepto de reinsercin forzada, para que la estructura del rbol sea
menos dependiente del orden de insercin, y dando lugar a un rbol ms compacto. Cuando
un nodo se desborda, no se divide inmediatamente, sino que una parte de las entradas del
nodo se reinsertan de nuevo. La reinsercin proporciona dos importantes mejoras: (1) se
reduce el nmero de divisiones de los nodos y, (2) es una tcnica para reorganizar el rbol de
forma dinmica. Debido a estas mejoras, el R*-tree generalmente obtiene un mejor
rendimiento que el R-tree convencional en el procesamiento de consultas espaciales.
Como sabemos, igual de importante es la creacin de mtodos de acceso para organizar
datos multidimensionales, como disear algoritmos eficientes para el procesamiento de
consultas sobre ellos. Por este motivo, definimos las consultas espaciales ms representativas
y diseamos los algoritmos que las implementan sobre el R*-tree, revisando el estado del arte
actual en este campo. Las consultas espaciales ms importantes sobre las que hemos diseado
algoritmos, utilizando el R*-tree como mtodo de acceso espacial, han sido las siguientes: (1)
consulta exacta y la consulta para la localizacin de un punto, (2) consultas en rango, (3)
consulta del vecino ms prximo, y (4) join espacial.


59


Captulo 3


CONSULTAS DE LOS PARES MS
CERCANOS



3.1 Introduccin

La mayora de los trabajos de investigacin dedicados al estudio de las consultas basadas en
distancias sobre mtodos de acceso multidimensionales se han centrado casi exclusivamente
en optimizar la consulta del vecino ms prximo o su extensin para los K vecinos ms
prximos, mejorando tanto las estructuras de datos utilizadas como los algoritmos que las
llevan a cabo. Recientemente, se estn diseando algoritmos para el procesamiento de
consultas basadas en distancias en las que interviene ms de un mtodo de acceso, utilizando
tcnicas basadas en el join y en la consulta del vecino ms prximo.
Una vez estudiado el R*-tree como estructura de datos arbrea multidimensional basada en
MBRs, balanceada en altura y almacenada en disco; junto con los algoritmos que
implementan las consultas espaciales que se pueden aplicar sobre l, vamos a introducir la
consulta base de esta tesis: la consulta del par ms cercano y su extensin a los K pares ms
cercanos. Empezaremos estableciendo los conceptos mtricos necesarios para presentar la
consulta en cuestin. Posteriormente, definiremos dicha consulta y propondremos algunas
aplicaciones de la misma fundamentalmente en el campo de las bases de datos espaciales. A
continuacin, se establece la relacin que existe entre la consulta del par ms cercano y el join
espacial con la consulta del vecino ms prximo. Por ltimo, se definen las mtricas entre
pares de MBRs y los teoremas que son la base para poder disear algoritmos branch-and-
bound eficientes que den solucin a la consulta en cuestin.

Captulo 3
60
3.2 La consulta del par ms cercano y su extensin a los K
pares ms cercanos

Antes de definir la consulta ncleo de esta tesis debemos introducir todos los conceptos
mtricos necesarios, adems de ver las diferencias y similitudes de nuestro problema con el
conocido problema del par ms cercano de un conjunto de puntos. Tambin, enunciaremos
algunos ejemplos de aplicacin de la consulta de los pares ms cercanos sobre bases de datos
espaciales como campo de aplicacin ms representativo.

3.2.1 Mtricas

En general, en problemas de geometra relativos a puntos en el espacio interviene el clculo
implcito o explcito de distancias entre dichos puntos. Por ejemplo, tal y como hemos visto
en el captulo anterior, un problema que se presenta en muchas aplicaciones es el de obtener el
vecino ms prximo entre un punto y un conjunto de puntos dado. La nocin de distancia se
utilizar para definir el concepto de espacio Eucldeo k-dimensional. ste es un caso especial
de espacio mtrico, que a su vez es un espacio topolgico con propiedades especiales. Un
espacio topolgico es un conjunto y una topologa sobre dicho conjunto. Una topologa
definida sobre un conjunto es una familia de subconjuntos que satisface ciertos axiomas. La
nocin de topologa, en un sentido muy general, establece un entorno formal y preciso para
fijar las ideas de cercana y continuidad.
Definicin. Espacio topolgico.
Sea P un conjunto y T P(P) un subconjunto del conjunto potencia de P o conjunto de las
partes de P. El par (P, T) se denomina espacio topolgico si satisface los tres axiomas
siguientes para todo U, V, S:
T A T S T
T V U T V T U T
T T P T
S A


U
) 3 (
, ) 2 (
, ) 1 (

En la definicin anterior, T es una topologa de P. A los elementos de T se les llama
conjuntos abiertos, y a sus complementarios en P(P) conjuntos cerrados. Los anteriores
axiomas nos dicen que y P son conjuntos abiertos (T1), que la interseccin de un nmero
finito de conjuntos abiertos es un conjunto abierto (T2), y que la unin de cualquier nmero
de conjuntos abiertos es un conjunto abierto (T3). Es decir, segn (T2) y (T3), T es cerrado
bajo un nmero finito de intersecciones y un nmero arbitrario de uniones de conjuntos
abiertos.

Consulta de los pares ms cercanos
61
Definicin. Mtrica y espacio mtrico.
Sea P un conjunto. Una mtrica sobre P es una funcin dist : PP (siendo el conjunto
de los nmeros reales) que satisface los siguientes axiomas para todo p, q, s P:
) , ( ) , ( ) , ( ) 4 (
) , ( ) , ( ) 3 (
0 ) , ( ) 2 (
0 ) , ( ) 1 (
q s dist s p dist q p dist M
p q dist q p dist M
q p q p dist M
q p dist M
+


La mtrica dist se denomina distancia entre dos puntos e induce una topologa sobre P
denominada topologa mtrica definida por dist. Al par (P, dist) se le denomina espacio
mtrico. Si A P, al par (A, dist
AA
) se le llama subespacio mtrico de P.
El primer axioma (M1) afirma que la distancia entre dos puntos p y q es no negativa, es
decir, que la distancia es siempre mayor o igual que cero (positividad). El axioma segundo
(M2) nos dice que la distancia entre dos puntos p y q es cero s y solo s los dos puntos
coinciden (identidad). El tercer axioma (M3) establece que dist es simtrica, ya que la
distancia entre p y q es independiente del orden de aplicacin de la mtrica (simetra), es
decir, no tiene una orientacin. El ltimo de los axiomas (M4) representa la desigualdad
triangular, en la que nos dice que la distancia entre los puntos p y s es menor o igual que la
suma de las distancias que existen entre p y q, por un lado y, q y s, por otro. Como ejemplo de
distancia mtrica sobre puntos definidos por coordenadas reales (elementos de P) tenemos la
L
t
-mtrica, L
t
-distancia o mtrica de Minkowski, d
t
(p, q), que pasamos a definir a
continuacin.
Definicin. L
t
-distancia o Mtrica de Minkowski.
Definimos la L
t
-distancia, d
t
(p, q), entre los puntos p = (p
1
, p
2
, ..., p
k
); p
i
y q = (q
1
, q
2
, ...,
q
k
); q
i
en el espacio k-dimensional como:
( )
,
_

t si q p q p d
t
k
i
t
i i t
1 , ,
/ 1
1

( )

t si q p q p d
i i
k i
, max ,
1

Para t = 2, tenemos la distancia Eucldea (d
2
), y para t = 1, tenemos la distancia Manhattan
(d
1
). La aplicabilidad de una distancia est fuertemente condicionada por el tipo de aplicacin.
Por ejemplo, la distancia Manhattan es muy apropiada para medir distancias en una ciudad,
donde los movimientos se tienen que efectuar siguiendo el trazado de las calles, lo que impide
recorridos en diagonal. Por otro lado, si necesitamos conocer la distancia que hay entre un
bosque y un lago, la distancia Eucldea es la ms apropiada.
Una propiedad de L
t
-distancia (propiedad de la distancia en una dimensin) dice que el
valor de la L
t
-distancia para una dimensin dada (1ik) es siempre menor o igual que el
valor total de L
t
-distancia para todas las dimensiones (k)
( ) ( ) t y k i si q p d q p i q p d
t i i t
1 1 , , , ,
Captulo 3
62
Los Espacios Eucldeos son importantes ejemplos de espacios mtricos. Como caso
especial, vamos a considerar el espacio Eucldeo k-dimensional (k es un nmero entero
positivo), que consiste en todas las tuplas k-dimensionales o puntos p = (p
1
, p
2
, ..., p
k
) de
nmeros reales que se pueden formar tal que p
i
, 1ik. La mtrica Eucldea est descrita
por la funcin de distancia Eucldea, basada en coordenadas reales.
Definicin. Espacio Eucldeo k-dimensional, E
(k)
.
El espacio Eucldeo k-dimensional (k es un nmero entero positivo) es el espacio mtrico
definido por, E
(k)
= {p = (p
1
, p
2
, ..., p
k
); p
i
, 1ik} con la topologa determinada por la
mtrica Eucldea (distancia Eucldea).


k
i
i i
q p q p d
1
2
) , (
Es decir, el espacio Eucldeo k-dimensional es el espacio k-dimensional de datos (D
(k)
)
dotado con la distancia Eucldea, y que denotamos como E
(k)
.
Por ejemplo, si tenemos dos puntos p y q en E
(2)
, con coordenadas p = (p
1
, p
2
) y q = (q
1
,
q
2
), obtenemos la siguiente expresin para la distancia Eucldea:
( )
2
2 2
2
1 1
, q p q p q p d +

3.2.2 El par ms cercano de un conjunto de puntos

El problema del par ms cercano es uno de los clsicos en geometra computacional y
consiste en encontrar los dos puntos ms cercanos entre s de un conjunto de puntos dado.
Para encontrar la distancia mnima entre dos puntos p y q perteneciendo a un conjunto de
puntos P, parecera necesario examinar las distancias entre todos los pares de puntos que se
derivan del conjunto original. Si la cardinalidad de P es N (|P| = N), esto podra significar un
tiempo de ejecucin proporcional a N
2
. No obstante, como veremos ms adelante, es posible
utilizar una ordenacin para examinar slo aproximadamente N*logN distancias entre puntos,
en el peor de los casos.
Definicin. Par ms cercano de un conjunto de puntos.
El par ms cercano de un conjunto de puntos P en el espacio Eucldeo k-dimensional, es un
par (p, q) de puntos distintos p, q P tal que la distancia entre p y q es mnima, siendo p =
(p
1
, p
2
, ..., p
k
) y q = (q
1
, q
2
, ..., q
k
).
Para resolver el problema del par ms cercano de un conjunto de N puntos en E
(2)
, en
[ShH75] se presenta un algoritmo con tiempo de ejecucin O(N*logN), y en [BeS76] aparece
un algoritmo para el caso general de dimensin k 2.
El algoritmo bsico [ShH75] utilizado para resolver este problema est basado en una
estrategia de divide y vencers. La idea es ordenar los puntos segn una coordenada, por
Consulta de los pares ms cercanos
63
ejemplo la coordenada X (dimensin 1), y utilizar despus esa ordenacin para dividir los
puntos en dos mitades segn una lnea divisoria. El par ms cercano del conjunto est en una
de las dos mitades o est formado por un elemento de cada mitad. Cuando el par ms cercano
est en una de las dos mitades se puede encontrar fcilmente procediendo recursivamente,
pero el problema surge cuando queremos comprobar eficazmente todos los pares cuyos
elementos estn uno a cada lado de la lnea divisoria.
Puesto que la nica informacin que se busca es encontrar el par ms cercano de un
conjunto de puntos, slo se necesita examinar los puntos que estn dentro de la distancia min
de la lnea divisoria, siendo min la menor de las distancias entre los pares ms cercanos
encontrados hasta el momento en las dos mitades. No obstante, esta observacin no es
suficiente en el peor caso, ya que pueden haber muchos pares de puntos muy cercanos a la
lnea divisoria. Para tratar tales situaciones, parece necesario ordenar los puntos segn la
coordenada Y (dimensin 2).
Despus se puede limitar el nmero de clculos de distancias que implican a cada punto,
recorriendo los puntos en orden ascendente de Y, y comprobando si cada uno est dentro de la
franja vertical que contiene a todos los puntos del plano situados a una distancia menor que la
distancia min de la lnea divisoria. Para cada punto que verifique dicha condicin, se calcula
la distancia entre l y otro punto cualquiera situado tambin dentro de la franja cuya
coordenada Y sea menor que la coordenada Y del punto en cuestin, pero en una cantidad que
no sea mayor que min. El hecho de que la distancia entre todos los pares de puntos de cada
mitad sea inferior a min significa que posiblemente se comprueben slo unos pocos puntos.
Desde el punto de vista de geometra computacional, el clculo del par ms cercano
descrito anteriormente es considerado esttico debido a que una vez encontrado el par ms
cercano no se realiza ninguna actualizacin del conjunto de puntos (entendindose como
actualizacin, cualquier insercin o eliminacin de uno o ms puntos del conjunto), para
seguir obteniendo el par ms cercano despus de una insercin o borrado de uno o ms puntos
en dicho conjunto.
Existen otras formas de obtener el par ms cercano de forma dinmica, siendo ste tambin
un problema muy estudiado desde el punto de vista de geometra computacional. Este
problema consiste, en dado un conjunto de N puntos en el espacio k-dimensional y una L
t
-
distancia, encontrar el par ms cercano despus de actualizar dicho conjunto. Es decir, que
dado un conjunto de puntos se debe gestionar una estructura de datos y un conjunto de
algoritmos sobre dicha estructura capaz de tener actualizado el par ms cercano de dicho
conjunto de puntos ante inserciones o eliminaciones. Para resolver este problema existen
muchos trabajos, siendo los ms representativos [ScS92, SSS92, Bes95].
El problema que nosotros planteamos para su resolucin no es abordado estrictamente
desde una perspectiva de geometra computacional, pero s se puede considerar una extensin
al descrito en [ShH75], ya que est enfocado desde un punto de vista esttico.


Captulo 3
64
3.2.3 Definicin de la consulta del par ms cercano y su extensin
a los K pares ms cercanos

En este epgrafe vamos a definir las consultas de los pares ms cercanos desde el punto de
vista de las bases de datos espaciales, donde cada objeto espacial est caracterizado por un
conjunto finito de atributos espaciales a los cuales se les puede aplicar una mtrica (distancia
Eucldea).
Definicin. Consulta del Par ms Cercano. CPC.
Dados dos conjuntos no vacos P y Q (P y Q ), la consulta del par ms cercano se
define como el siguiente conjunto:
CPC(P, Q) = {(O, O) PQ: (O
i
, O
j
) PQ {(O, O)}, d(O, O) d(O
i
, O
j
)}
En nuestro caso, todos los objetos de P y Q tienen asociado un conjunto de atributos
espaciales A
P
y A
Q
tal que los objetos espaciales O.A
P
y O.A
Q
pertenecen a E
(k)
, y d es la
distancia Eucldea.
Es decir, la Consulta del Par ms Cercano (CPC) de dos conjuntos de objetos espaciales P
y Q nos devuelve un par que tiene la distancia Eucldea ms pequea entre todos los posibles
pares de objetos espaciales que se pueden formar escogiendo un objeto de P y otro objeto de
Q.
La extensin de esta consulta para el caso general de obtener los K pares ms cercanos se
muestra a continuacin.
Definicin. Consulta de los K Pares ms Cercanos. K-CPC.
Dados dos conjuntos no vacos P y Q (P y Q ), la consulta de los K pares ms
cercanos se define como un conjunto conteniendo subconjuntos de PQ, cada uno de ellos
con K (1K|P||Q|) pares de objetos distintos y ordenados en ranking segn su distancia. Es
decir, como el siguiente conjunto:
K-CPC(P, Q, K) = {{(O
1
, O
1
), (O
2
, O
2
), ..., (O
K
, O
K
)} PQ; (O
i
, O
i
) (O
j
, O
j
) i j:
(O
i
, O
j
) PQ {(O
1
, O
1
), (O
2
, O
2
), ..., (O
K
, O
K
)}, O
i
P, O
j
Q,
d(O
1
, O
1
) d(O
2
, O
2
) ... d(O
K
, O
K
) d(O
i
, O
j
)}
En este caso, al igual que para CPC, todos los objetos de P y Q tienen asociado un
conjunto de atributos espaciales A
P
y A
Q
tal que los objetos espaciales O.A
P
y O.A
Q

pertenecen a E
(k)
, y d es la distancia Eucldea.
Es decir, la Consulta del los K Pares ms Cercanos (K-CPC) de dos conjuntos de objetos
espaciales P y Q definidos en E
(k)
, nos devuelve un conjunto conteniendo subconjuntos de K
pares de objetos espaciales distintos y ordenados ascendentemente segn su distancia
Eucldea, y que tienen las K distancias ms pequeas entre todos los posibles pares de objetos
espaciales que se pueden formar escogiendo un objeto de P y otro objeto de Q.
Evidentemente, K debe ser menor o igual que |P||Q|, donde |P| y |Q| es el nmero de objetos
Consulta de los pares ms cercanos
65
de P y Q, respectivamente. Es decir, K debe ser menor que el nmero total de pares de objetos
espaciales que se pueden formar de los conjuntos P y Q.
En general, esta consulta es como un join en el sentido de que todos los pares de objetos
espaciales son candidatos al resultado final, y como una consulta del vecino ms prximo en
el sentido de que las mtricas y heursticas de poda para algoritmos branch-and-bound son
similares para reducir el espacio de bsqueda y generar el conjunto resultado en un orden
determinado (ranking).
Debemos destacar que se puede dar el caso de que existan pares de objetos espaciales con
la misma distancia Eucldea, y en ese caso el resultado de CPC o K-CPC puede no ser nico
para dos conjuntos de objetos espaciales P y Q dados. Es decir, para el caso de CPC puede
que haya ms de un par con la misma distancia mnima y dependiendo del algoritmo que se
aplique d una solucin u otra. Por ejemplo, supongamos que tenemos como pares de puntos
candidatos en E
(2)
a ser el par ms cercano (p
1
, q
7
), (p
5
, q
6
) y (p
2
, q
9
), todos con distancia igual
a 2.83174 y sta es la menor de todas las posibles distancias de pares que se pueden formar al
combinar todos los puntos de P con todos los puntos de Q. Cualquiera de ellos puede ser el
par ms cercano dependiendo del algoritmo que se aplique para determinarlo. Esta situacin
para el caso de K-CPC es muy similar, supongamos que tenemos los mismos conjuntos de
datos (P y Q), y que nuevamente estn como pares candidatos a ser los 3 pares ms cercanos
(K = 3) (p
1
, q
7
), (p
5
, q
6
) y (p
2
, q
9
) y todos con distancia igual a 2.83174, siendo sta la menor
de todas las posibles distancias de pares que se pueden formar al combinar todos los puntos de
P con todos los puntos de Q. Cualquiera de las siguientes agrupaciones es candidata a ser los
3 pares ms cercanos {(p
1
, q
7
), (p
5
, q
6
), (p
2
, q
9
)}, {(p
1
, q
7
), (p
2
, q
9
), (p
5
, q
6
)}, {(p
5
, q
6
), (p
1
, q
7
),
(p
2
, q
9
)}, {(p
5
, q
6
), (p
2
, q
9
), (p
1
, q
7
)}, {(p
2
, q
9
), (p
1
, q
7
), (p
5
, q
6
)} o {(p
2
, q
9
), (p
5
, q
6
), (p
1
, q
7
)},
segn el algoritmo que se aplique. Por lo tanto, el objetivo principal que se persigue es
obtener una instancia de todos los posibles subconjuntos solucin que se pueden generar para
obtener CPC o K-CPC, y no todos ellos, aunque generar todos los posibles subconjuntos de K
pares ms cercanos no es tarea difcil [Ast00].
Por ejemplo, la situacin que se puede plantear para K-CPC cuando no existe un nico
subconjunto solucin es que para el mismo valor de distancia del par ms lejano de los K
pares ms cercanos exista un nmero de pares que exceda K. Es decir, que el par (K+i)simo
(i 1) tenga el mismo valor de distancia que el par K-simo (par ms lejano de los K pares
ms cercanos). Entonces los i pares con ese mismo valor de distancia habr que considerarlos
como elementos del resultado final, devolvindolos en una estructura de datos adicional. Con
este caso particular, queremos decir que los algoritmos que procesan las consultas de los pares
ms cercanos (CPC y K-CPC) devolvern el resultado en dos estructuras de datos: (1) un
conjunto principal no vaco formado por el par ms cercano (CPC) o por los K pares ms
cercanos (K-CPC), y (2) un conjunto adicional, vaco o no, con los i pares con el mismo valor
de distancia que el K-simo par del conjunto principal.
En la Figura 3.1 podemos observar un ejemplo donde hay dos conjuntos P y Q con tres
puntos cada uno, definidos en E
(2)
, P = {p
1
, p
2
, p
3
} (Figura 3.1.a) y Q = {q
1
, q
2
, q
3
} (Figura
3.1.b). Los puntos del conjunto P los etiquetamos con cruces y a los puntos de Q con
asteriscos. El mnimo rectngulo que envuelve (MBR) cada conjunto est representado con un
MBR en lneas discontinuas, y rotulamos con un MBR en lneas continuas a una parte del
plano. Para poder distinguir de forma visual los pares ms cercanos de estos conjuntos, en la
Figura 3.1.c aparecen los dos conjuntos de puntos juntos. Es evidente que el par ms cercano
Captulo 3
66
de puntos (CPC) es (p
3
, q
1
) y los 2 pares ms cercanos (2-CPC) son {(p
3
, q
1
), (p
2
, q
2
)}.
Comprobando las distancias de los restantes pares que se pueden formar de los dos conjuntos
de puntos P y Q, podemos observar que los 3 pares de puntos ms cercanos (3-CPC) son {(p
3
,
q
1
), (p
2
, q
2
), (p
3
, q
2
)}, y los 4 pares ms cercanos (4-CPC) son {(p
3
, q
1
), (p
2
, q
2
), (p
3
, q
2
), (p
3
,
q
3
)}, y as sucesivamente. Es interesante notar que los MBRs de los dos conjuntos de puntos P
y Q estn parcialmente solapados. Evidentemente, cuanto ms grande es la porcin de solape
entre los dos MBRs de los conjuntos de puntos, mayor es la probabilidad de que aparezcan
ms pares con distancias pequeas. Un algoritmo que responda a la consulta de los K pares
ms cercanos tendr que examinar muchos pares candidatos con distancias que difieran entre
ellas muy poco al existir un elevado porcentaje de solape entre los MBRs de los conjuntos de
datos, y requerir ms recursos para poder llevar a cabo la consulta.

+ p
1

+ p
3

+ p
2

(a)
* q
1

* q
3

* q
2

(b)
+ p
1

+ p
3

+ p
2

* q
1

* q
3

* q
2

(c)
P P
Q Q

Figura 3.1 Dos conjuntos de puntos en E
(2)
.

3.2.4 Ejemplos de aplicacin de las consultas de los pares ms
cercanos sobre datos espaciales

Existen muchos tipos de consultas en la vida real para los que es necesario la obtencin del
par ms cercano o de los K pares ms cercanos. Un ejemplo representativo de este tipo de
consulta utilizando informacin espacial, podra ser el siguiente:
Informacin espacial: P = conjunto de objetos espaciales que representan las
ubicaciones de hoteles de una determinada regin (provincia de Almera). Q = Conjunto
de objetos espaciales que representan las posiciones geogrficas referentes a puntos de
inters turstico dentro de la misma regin.
Consulta: Determinar el conjunto de los K pares de objetos (hotel, centro turstico)
ms prximos entre s. Es decir, encontrar aquellos pares de objetos que tienen los K
valores de distancias ms pequeos, para que los turistas acomodados en un hotel
puedan visitar fcilmente un centro turstico sin necesidad de recorrer un largo trayecto.
Utilidad: La utilidad de esta consulta es ayudar a una empresa que se dedica a
organizar excursiones a centros tursticos, a decidir la ruta a seguir sobre determinados
hoteles de forma que por tener cerca un lugar de inters turstico no molesten demasiado
a sus clientes a la hora de realizar los desplazamientos.
Consulta de los pares ms cercanos
67
En este ejemplo, gestionamos informacin espacial que puede estar integrada en un
sistema de base de datos espacial. Segn [Gt94] se define un sistema de base de datos
espacial (SBDE) como aqul que verifica las siguientes propiedades:
1. Es un sistema de base de datos. Segn [ElN97], SBD est formado bsicamente por la
base de datos, el diccionario de datos, el sistema de gestin de base de datos (SGBD) y
por la interfaz.
2. Ofrece tipos de datos espaciales en su modelo de datos y un lenguaje de consulta para
manipularlos.
3. Soporta los tipos de datos espaciales en su implementacin, suministrando mtodos de
indexacin espaciales y algoritmos eficientes para el procesamiento de consultas.
El objetivo principal para integrar aspectos espaciales en un modelo de datos de un SGBD
es representar objetos espaciales (puntos, lneas, regiones, etc.) como objetos del modelo de
datos del SGBD con al menos un atributo de un tipo de dato espacial. Por tanto, el modelo de
datos del SGBD debe ser extendido por los tipos de datos espaciales a nivel de tipos de datos
elementales (tales como, enteros, cadenas, ...) o mejor an que soporte tipos de datos
definidos por el usuario. La mayora de los sistemas de gestin de bases de datos espaciales
(SGBDE) han utilizado como base el modelo de datos relacional, como por ejemplo, SIRO-
DBMS [Abe89], GEOVIEW [WaH87], SAND [ArS91], Gral [Gt89], PROBE [OrM88],
GEO-KERNEL [ScW86] y GEO++ [ViO92] son los ms conocidos. Los modelos de datos
basados en objetos tambin pueden ser utilizados como base de un SBDE, por ejemplo en
[ScV92] se describe un GIS construido sobre el SGBD orientado a objetos O2. Paradise
[DKL
+
94, Par97] y Predator [SeP97] son SGBD objeto-relacionales [StM97], en el sentido de
que el procesamiento de consultas relacionales se realiza con un SQL extendido, y suministra
un conjunto de tipos de datos espaciales y operadores sobre dichos tipos de datos.
Como acabamos de ver, existen muchas alternativas para la extensin espacial de un
SGBD de diferente naturaleza (relacional, orientado a objetos, etc.). Por ello, para nuestro
ejemplo, suponemos que dicha extensin espacial existe y est bien definida.
Un objeto en un sistema de bases de datos espacial normalmente est definido por varios
atributos no espaciales y por un atributo de algn tipo de dato espacial (punto, lnea, regin,
polgono, etc.). En nuestro esquema ejemplo, al igual que en [SaA95], vamos a considerar
relaciones que contienen informacin (atributos) espacial expresada por tipos de datos
espaciales como: POINT (puntos), LINE_SEGMENT (segmentos de lnea), REGION
(regiones) POLYGON (polgonos), BOX (rectngulos), etc. En particular, vamos a
considerar los puntos (POINT) que representan la localizacin espacial de hoteles y lugares
de inters turstico de la provincia de Almera.
Para la definicin de esquemas relacionales en un SGBD extendido que soporte tipos de
datos espaciales, podemos utilizar la sintaxis de la orden CREATE TABLE de SQL como en
[SaA95]. En nuestro ejemplo, las definiciones de las relaciones (tablas) con atributos
espaciales seran las siguientes:
CREATE TABLE Hoteles
( hotel_id NUMBER,
Captulo 3
68
hotel_nombre CHAR(30),
hotel_direccion CHAR(60),
hotel_categoria CHAR(10),
hotel_equipamiento CHAR(30),
hotel_cadena CHAR(30),
hotel_telefono NUMBER,
hotel_fax NUMBER,
hotel_email CHAR(30),
hotel_www CHAR(60),
hotel_localizacion POINT ); // Atributo espacial
CREATE TABLE LugaresTuristicos
( lugarturistico_id NUMBER,
lugarturistico_nombre CHAR(30),
lugarturistico_direccion CHAR(60),
lugarturistico_categoria CHAR(10),
lugarturistico_localizacion POINT ); // Atributo espacial
Un ejemplo tpico sobre el esquema espacial anterior para la consulta de los pares ms
cercanos podra ser el siguiente: encontrar el nombre, direccin y telfono de los 10 hoteles
ms cercanos a cualquier lugar de inters turstico, devolviendo el nombre y la direccin de
los lugares de inters turstico. Adems, el resultado debe estar ordenado ascendentemente
en base a su distancia.
Para expresar esta consulta necesitamos hacer uso de la clusula STOP AFTER en un
SQL extendido que procese informacin espacial. En [CaK97] se hace una extensin de SQL
con el objetivo de limitar la cardinalidad del resultado de una consulta para un nmero de
tuplas definido por el usuario, para lo que incluye la clusula STOP AFTER como un sufijo
opcional. De igual forma, suponemos que el tipo de dato espacial POINT tiene asociada la
funcin distance que devuelve la distancia entre dos puntos en E
(2)
. La sentencia SQL para
nuestro ejemplo sera la siguiente:
SELECT h.hotel_nombre, h.hotel_direccion, h.hotel_telefono, l.lugarturistico_nombre,
l.lugarturistico_direccion
FROM Hoteles h, LugaresTuristicos l
WHERE distance(h.hotel_localizacion, l.lugarturistico_localizacion) 0
ORDER BY distance(h.hotel_localizacion, l.lugarturistico_localizacion)
STOP AFTER 10;
Otro ejemplo de consulta para determinar pares de objetos espaciales ms cercanos muy
parecida a la anterior y sin utilizar la clusula STOP AFTER sera por ejemplo: encontrar el
nombre, direccin y telfono de todos los hoteles que estn a menos de 5 kilmetros de
cualquier lugar turstico, devolviendo el nombre y la direccin de los lugares tursticos.
Adems, el resultado debe estar ordenado ascendentemente en base a su distancia.
SELECT h.hotel_nombre, h.hotel_direccion, h.hotel_telefono, l.lugarturistico_nombre,
l.lugarturistico_direccion
FROM Hoteles h, LugaresTuristicos l
WHERE distance(h.hotel_localizacion, l.lugarturistico_localizacion) 0 AND
Consulta de los pares ms cercanos
69
distance(h.hotel_localizacion, l.lugarturistico_localizacion) 5
ORDER BY distance(h.hotel_localizacion, l.lugarturistico_localizacion);
Evidentemente, podemos combinar estos dos tipos de consultas espaciales relacionadas
con los pares ms cercanos y generalizar el enunciado diciendo: determinar el nombre,
direccin y telfono de los K hoteles ms cercanos a cualquier lugar de inters turstico,
devolviendo de este ltimo el nombre y la direccin estando a una distancia menor de D
kilmetros. Adems, el resultado debe estar ordenado ascendentemente en base a su
distancia.
Despus de haber visto el ejemplo de los hoteles y los lugares tursticos, podemos
considerar otros tales como:
Informacin espacial: P = Conjunto de objetos espaciales que representan las
localizaciones geogrficas de centralitas de conexin de una compaa telefnica para
una ciudad determinada (Almera). Q = Conjunto de objetos espaciales que representan
las posiciones geogrficas de edificios en construccin (potenciales conexiones a lneas
telefnicas) dentro de la misma ciudad.
Consulta: Determinar el conjunto de los K pares de objetos (centralita de conexin,
edificio en construccin) ms cercanos entre s. Es decir, la ubicacin de las centralitas
ms cercanas a cualquier edificio en construccin.
Utilidad: La utilidad de esta consulta es ayudar a una empresa que se dedica a la
instalacin de lneas telefnicas, para indicarle cul es la centralita de conexin
telefnica ms cercana a cualquier edificio en construccin, ahorrando con ello en el
cableado necesario para la conexin telefnica. Aclaracin: Para esta aplicacin es
necesario utilizar la distancia Manhattan en lugar de distancia Eucldea, ya que no tiene
sentido atravesar los edificios para instalar el cableado de una lnea.
Informacin espacial: P = Conjunto de objetos espaciales que representan la posicin
geogrfica de los pozos de agua en una determinada regin (provincia de Granada). Q =
Conjunto de objetos espaciales que representan las ubicaciones geogrficas de los
ncleos de poblacin de otra regin (provincia Almera).
Consulta: Determinar el conjunto de los K pares de objetos (pozo, ncleo de
poblacin) ms cercanos entre s.
Utilidad: El objetivo de esta consulta es obtener el pozo de agua que se puede
encontrar en la provincia de Granada ms cercano a cualquier ncleo de poblacin de la
provincia de Almera en orden ascendente de distancia. La utilidad radica en tener la
posibilidad de realizar un trasvase de agua con el menor coste posible. Aclaracin.
Debemos destacar que para este tipo de consulta el porcentaje de solape (overlap) entre
las dos reas que envuelven los datos espaciales es del 0%, es decir, los conjunto son
totalmente disjuntos.
Otros ejemplos muy representativos que gestionan informacin espacial y a los cuales se le
puede aplicar las consultas de los pares ms cercanos son: almacenes y tiendas, taxis y
paradas de taxis, ciudades y autovas, etc. Evidentemente, podemos definir esquemas
relacionales en un SGBD extendido que permita tipos de datos espaciales y generar sentencias
en un SQL extendido que soporte consultas de esta naturaleza.

Captulo 3
70
3.3 Las consultas join y el vecino ms prximo, como base
para las consultas de los pares ms cercanos

Como hemos comentado anteriormente, la consulta del par ms cercano o de los K pares ms
cercanos es como un join en el sentido de que todos los pares de objetos espaciales son
candidatos para el resultado final, y como una consulta del vecino ms prximo en el sentido
de que mtricas basadas en distancias y heursticas de poda aplicadas en algoritmos branch-
and-bound son similares, con el objetivo de reducir el espacio de bsqueda y generar el
conjunto resultado en un orden determinado (ranking). Debido a esto, vamos a estudiar las
aportaciones de estos dos tipos de consultas a las de los pares ms cercanos.

3.3.1 Join utilizando R*-trees

En [Bec92] se define la consulta join sobre estructuras de archivos multidimensionales como
aquella que, dados dos conjuntos de objetos P y Q en el espacio multidimensional de datos
D
(k)
y un predicado , encuentra todos los pares de objetos (p, q) P Q donde la
evaluacin del predicado (p, q) es cierta, es decir,
JE(P, Q, ) = {(p, q) PQ : (p, q)}
El predicado puede ser simple o compuesto, y de diferente naturaleza dependiendo de
los datos que se vayan a relacionar. Realmente, esta consulta devuelve un subconjunto de
producto cartesiano de los dos conjuntos de objetos que satisface el predicado .
Existen muchos algoritmos para resolver esta consulta, tal ycomo hemos visto para el join
espacial en el captulo 2, pero como las estructuras de datos base de esta tesis son los R*-
trees, slo nos vamos a preocupar de los algoritmos (recursivos e iterativos) sobre mtodos de
acceso multidimensionales arbreos basados en MBRs, balanceados en altura y almacenados
en disco que van a generar todos los posibles pares de objetos candidatos al resultado final
(producto cartesiano).
Desde el punto de vista recursivo, nos basamos en la idea de [BKS93a] para esta consulta,
que sigue un recorrido sincronizado en profundidad sobre los dos R*-trees, y el predicado
que debe satisfacer es el predicado espacial solapa (join espacial), el cual se aplica tanto a los
pares de objetos espaciales como a los pares de MBRs procedentes de la combinacin de los
elementos de ambos R*-trees.
Desde un punto de vista iterativo (no recursivo), vamos a considerar dos alternativas. La
primera est basada en el trabajo de [HjS98], donde todos los posibles pares que se obtienen
de la concatenacin de los dos R*-trees se organizan en una cola de prioridad (implementada
como un montculo) cuya clave de ordenacin es la mnima distancia entre los elementos que
forman el par. La segunda alternativa est basada en la idea propuesta en [HJR97a], donde se
Consulta de los pares ms cercanos
71
plantea un algoritmo iterativo que concatena ambos R*-trees segn una poltica de recorrido
en anchura, siendo nuevamente el predicado espacial solapa.
Es decir, nos vamos a basar en el join para resolver las consultas de los pares ms cercanos
(CPC y K-CPC), en el sentido de utilizar la estructura de los algoritmos sobre mtodos de
acceso multidimensionales arbreos para generar todos los posibles pares de objetos
candidatos al resultado final.

3.3.2 La consulta del par ms cercano utilizando R*-trees

En [RKV95, HAK00] se define la consulta de vecino ms prximo de la siguiente forma:
dado un punto p = (p
1
, p
2
, ..., p
k
) en E
(k)
, encontrar el objeto O perteneciente a un conjunto de
objetos P ms prximo a p.
CVP(p, P) = {O P: O P {O}, d(p, O) d(p, O)}
La extensin de esta consulta para obtener los K vecinos ms prximos es sencilla y
consiste en dado un punto p en E
(k)
, encontrar los K objetos distintos {O
1
, O
2
, ..., O
K
}
pertenecientes a un conjunto de objetos P ms prximos a p. Para ello, definimos una
coleccin de K objetos ordenados y distintos,
K-CVP(p, P, K) = {{O
1
, O
2
, ..., O
K
} P; O
i
O
j
i j:
O P {O
1
, O
2
, ..., O
K
}, d(p, O
1
) d(p, O
2
) ... d(p, O
K
) d(p, O)}
En [RKV95] se propone un algoritmo branch-and-bound recursivo para encontrar el vecino
ms prximo sobre R-trees (CVP_Recursivo, algoritmo recursivo visto en el captulo 2), que
a su vez es una extensin del presentado en [FBF77] para k-d-trees. La idea fundamental de
este algoritmo es que muchas ramas del R-tree pueden podarse en base a unas reglas
derivadas de unas distancias definidas entre un punto p = (p
1
, p
2
, ..., p
k
) y un MBR R definido
por dos puntos (s, t) en E
(k)
[RKV95, PaM98].
Definicin. Mnima distancia de un punto a un objeto en E
(k)
.
La distancia mnima de un punto p a un objeto o, representada por ||(p, o)||, en E
(k)
, se define
segn [RKV95] como:
( ) o x x x x x p o p
k
k
i
i i

'

,..., , , min ) , (
2 1
1
2

De forma equivalente podemos definir esta misma distancia en funcin de las caras del
objeto en E
(k)
(u objeto multidimensional), basndonos en los conceptos establecidos en
[PrS85, RSV01]. Se define k-polytope convexo como la envolvente convexa de un conjunto
finito de puntos en E
(k)
. Este k-polytope convexo se describe en funcin de su frontera, la
cual est formada por caras. Una cara de un k-polytope convexo es otro polytope
convexo de una dimensin menor ((k 1)-polytope); una k-cara denota una cara k-
Captulo 3
72
dimensional. Si tenemos un k-polytope, a sus (k 1)-caras se le denomina facets, a sus (k
2)-caras se le denomina subfacets, sus 1-caras son las aristas y las 0-caras son los vrtices.
Por ejemplo, para un 3-polytope, facets son polgonos planos, mientras que subfacets y aristas
coinciden. Adems, la unin de un nmero finito de (k 1)-polytopes es un poliedro k-
dimensional en E
(k)
, no necesariamente convexo y sus componentes no necesitan estar
forzosamente conectados. Por ejemplo, una forma de definir regiones, poly-lneas y puntos
sera considerar poliedros de dimensin 2, 1 y 0.
Definicin. Mnima distancia de un punto a un objeto en E
(k)
en funcin de las caras del
objeto.
La distancia mnima de un punto p a un objeto o caracterizado por su conjunto de caras,
representada por ||(p, o)||, en E
(k)
, se define como:
{ } { } ) , ( min min ) , (
) ( f f p o F f
p p d o p
f


donde F(o) es el conjunto de caras que forman el objeto o en E
(k)
. Adems, f es una instancia
de esas caras en F(o), y d es la funcin que calcula la distancia entre dos puntos p y p
f
,
definida en E
(k)
, donde p
f
es un punto en alguna de las caras de o.
La primera mtrica entre un punto p y un MBR R en E
(k)
, se denomina MinDist(p, R). Esta
mtrica, de forma intuitiva, representa el mnimo valor de distancia desde un punto a un MBR
definido por dos puntos.
Definicin. MinDist(p, R).
Dado un punto p = (p
1
, p
2
, ..., p
k
) y un MBR R = (s, t), donde s = (s
1
, s
2
, ..., s
k
) y t = (t
1
, t
2
, ...,
t
k
) tal que s
i
t
i
, 1ik, en E
(k)
, se define MinDist(p, R) de la siguiente manera:


k
i
i i
r p R p MinDist
1
2
) , (
donde,

'

>
<

casos otros los en p


t p si t
s p si s
r
i
i i i
i i i
i
,
,
,

Debemos destacar que MinDist(p, R) requiere un orden lineal para su clculo O(k),
dependiendo del nmero de dimensiones que se consideren en E
(k)
.
Teorema 3.1.
Dado un punto p = (p
1
, p
2
, ..., p
k
) y el MBR R que envuelve a un conjunto de objetos O = {o
i
,
1iN} en E
(k)
, entonces para todo o
i
perteneciente a O se verifica que:
) , ( ) , (
i
o p R p MinDist
Demostracin: [RKV95].
La segunda mtrica entre un punto p y un MBR R en E
(k)
, es la denominada
MinMaxDist(p, R). Esta mtrica, de forma intuitiva, representa el mnimo valor de todas las
mximas distancias entre un punto yun MBR sobre cada una de las k dimensiones. Es decir,
sta es la mxima distancia entre el punto y la cara ms prxima del MBR, donde F(R) es el
Consulta de los pares ms cercanos
73
conjunto de caras que forman el MBR R en E
(k)
. MinMaxDist(p, R) garantiza que hay un
objeto dentro del MBR con un valor de distancia a p menor o igual que el suministrado por
dicha mtrica. Por ello, MinMaxDist(p, R) nos proporciona una cota superior para el vecino
ms prximo de un punto.
( ) ( ) ( ) R F x x x x x p R p MinMaxDist
k
k
i
i i

'

'

,..., , , max min ,


2 1
1
2

Definicin. MinMaxDist(p, R).
Dado un punto p = (p
1
, p
2
, ..., p
k
) y un MBR R = (s, t), donde s = (s
1
, s
2
, ..., s
k
) y t = (t
1
, t
2
, ...,
t
k
) tal que s
i
t
i
, 1ik, en E
(k)
, definimos MinMaxDist(p, R) de la siguiente manera:

'

+



k
j i i
i i j j
k j
rM p rm p R p MinMaxDist
, 1
2
2
1
min ) , (
donde,
( )

'
+

casos otros los en t


t s
p si s
rm
j
j j
j j
j
,
2
,
y,
( )

'
+

casos otros los en t


t s
p si s
rM
i
i i
i i
i
,
2
,

El algoritmo para el clculo de MinMaxDist(p, R) entre un punto p y un MBR R en E
(k)
,
tiene un coste computacional de O(k) [RKV95].
Teorema 3.2.
Dado un punto p = (p
1
, p
2
, ..., p
k
) y el MBR R que envuelve a un conjunto de objetos O = {o
i
,
1iN} en E
(k)
, existe un o
i
O tal que:
) , ( ) , ( R p MinMaxDist o p
i

Demostracin. [RKV95].
La ltima mtrica entre un punto p y un MBR R propuesta en [PaM98] es la denominada
MaxDist(p, R) y representa la mxima distancia desde el punto p hasta un MBR R delimitado
por dos puntos en E
(k)
.
( ) ( ) ( ) R F x x x x x p R p MaxDist
k
k
i
i i

'

'

,..., , , max max ,


2 1
1
2

Definicin. MaxDist(p, R).
Dado un punto p = (p
1
, p
2
, ..., p
k
) y un MBR R = (s, t), donde s = (s
1
, s
2
, ..., s
k
) y t = (t
1
, t
2
, ...,
t
k
) tal que s
i
t
i
, 1ik, en E
(k)
, definimos MaxDist(p, R) de la siguiente manera:


k
i
i i
r p R p MaxDist
1
2
) , (
Captulo 3
74
donde,
( )

'
+

casos otros los en s


t s
p si t
r
i
i i
i i
i
,
2
,

Teorema 3.3.
Dado un punto p = (p
1
, p
2
, ..., p
k
) y el MBR R que envuelve a un conjunto de objetos O = {o
i
,
1iN} en E
(k)
, se verifica para todo o
i
en O:
) , ( ) , ( R p MaxDist o p
i

Demostracin: [PaM98].
En la Figura 3.2 se representan las tres distancias representativas entre un punto y un MBR
en E
(2)
.

p
R
1

R
2

MinDist
MinMaxDist
MaxDist

Figura 3.2 MinDist, MinMaxDist y MaxDist entre un punto p y los MBRs R
1
y R
2
en E
(2)
.
Las mtricas, MinDist(p, R) y MinMaxDist(p, R) junto con los teoremas 3.1 y 3.2 se
utilizan en tres reglas bsicas que se aplican para realizar la poda del R*-tree cuando se
recorre ste desde la raz hasta las hojas segn un algoritmo branch-and-bound para encontrar
el vecino ms prximo [RKV95]. Las heursticas de poda son las siguientes:
1. Por los teoremas 3.1 y 3.2. Si un MBR R tiene MinDist(p, R) mayor que MinMaxDist(p,
R) de otro MBR R, entonces el MBR R se descarta porque no puede incluir al vecino
ms prximo a p. Es decir, si MinDist(p, R) > MinMaxDist(p, R), entonces el MBR R
se descartar.
2. Por el teorema 3.2. Si la distancia Eucldea actual desde p hasta un objeto dado O, es
mayor que MinMaxDist(p, R) desde p hasta un MBR R, entonces podemos descartar a
dicho objeto. Es decir, si DistanciaEuclidea(p, O) > MinMaxDist(p, R), entonces el
objeto O se descartar.
3. Por el teorema 3.1. Si T es la distancia Eucldea procesada hasta el momento para el
vecino ms prximo o los K vecinos ms prximos, entonces descartamos todos los
MBRs R
i
con distancia MinDist(p, R
i
) mayor que T, porque ellos no pueden envolver un
vecino ms prximo o los K vecinos ms prximos a p. Es decir, si MinDist(p, R) > T,
entonces el MBR R se descartar.
Las reglas (1) y (2) se utilizan para descartar ramas irrelevantes y seleccionar una hoja de
acuerdo con un orden. En [RKV95], se propuso ordenar ascendentemente los MBR R
i

Consulta de los pares ms cercanos
75
candidatos segn MinDist(p, R
i
), porque se eliminan ramas candidatas de forma ms rpida
conforme el algoritmo progresa.
Para el caso genrico del los K vecinos ms prximos (K-CVP), adems de aplicar la regla
(3) y utilizar un montculo mximo adicional con los K vecinos ms prximos procesados
hasta el momento, situando en la raz el de mayor distancia, podemos hacer uso del teorema
3.3 (MaxDist(p, R)). Si conocemos el nivel del nodo del R*-tree que se est procesando
actualmente, junto con la cota inferior del factor de ramificacin de dicho rbol (m), estamos
en condiciones de podar ramas innecesarias actualizando T, tal y como se propone en
[PaM98]. Para este caso no se utiliza la mtrica MinMaxDist(p, R).
En la Figura 3.3 se puede observar los MBRs aceptados (R
3
y R
5
, en lneas continuas) y
descartados (R
1
, R
2
, R
4
y R
6
, en lneas de puntos) aplicando las estrategias de poda basadas en
MinMaxDist(p, R) para obtener el vecino ms prximo. Realmente, aplicamos la heurstica
(1), ya que el mnimo valor para MinMaxDist(p, R) es MinMaxDist(p, R
3
) = T, y despus
debemos descartar todos los MBRs que verifiquen la siguiente condicin: MinDist(p, R
i
) >
MinMaxDist(p, R
3
) = T, y en nuestro ejemplo, R
i
= R
1
, R
2
, R
4
y R
6
.

R
1

R
2

R
3

R
4

R
5

R
6

MinDist
MinMaxDist
p

Figura 3.3 Aplicacin de la estrategia de poda para encontrar el vecino ms prximo.
En resumen, nos vamos a basar en la consulta del vecino ms prximo en el sentido de que
propondremos unas distancias entre pares de MBRs definidos por dos puntos en E
(k)
, y unas
propiedades sobre esas mtricas (heursticas de poda) que nos servirn para disear
algoritmos branch-and-bound que llevan a cabo un proceso de poda durante el recorrido
simultneo sobre ambos R*-trees, obteniendo el par ms cercanos o los K pares ms cercanos.



Captulo 3
76
3.4 Mtricas entre pares de MBRs para el procesamiento
de las consultas de los pares ms cercanos

Debido a que los diferentes algoritmos branch-and-bound que se propondrn para determinar
las consultas de los pares ms cercanos actan sobre pares de MBRs procedentes de la
combinacin de dos R*-trees, debemos definir mtricas entre pares de MBRs para aplicarlas
como mecanismos de poda en dichos algoritmos. Adems, sabemos que un MBR en E
(k)
representa el mnimo rectngulo definido por dos puntos que envuelve a un objeto en E
(k)
o a
un conjunto de objetos en E
(k)
, siendo sus caras paralelas a los ejes de coordenadas en cada
dimensin.
Las mtricas ms importantes que vamos a definir entre pares de MBRs en E
(k)
, son
MinMinDist(R
1
, R
2
), MinMaxDist(R
1
, R
2
) y MaxMaxDist(R
1
, R
2
), cuyo significado es el
siguiente:
1. MinMinDist(R
1
, R
2
). Representa la mnima distancia que hay entre dos MBRs, R
1
y R
2
.
2. MinMaxDist(R
1
, R
2
). Representa la mnima de todas las mximas distancias entre las
caras paralelas ms prximas de dos MBRs, R
1
y R
2
, para cada una de las dimensiones.
3. MaxMaxDist(R
1
, R
2
). Representa la mxima distancia que hay entre dos MBRs, R
1
y R
2
.
La primera mtrica que vamos a introducir, MinMinDist(R
1
, R
2
), es una extensin de la
definicin de MinDist(p, R) hecha en [RKV95] entre un punto y un MBR, pero aplicada entre
dos MBRs definidos en E
(k)
.
Definicin. Mnima distancia entre MBRs, MinimaDistancia(R
1
, R
2
).
La mnima distancia entre dos MBRs, R
1
y R
2
, definidos en E
(k)
, denotada como
MinimaDistancia(R
1
, R
2
), es la menor de las distancias entre las caras que los forman y se
define como:
( ) ( ) { } { }
2 1 , ) ( ), ( 2 1
, min min ,
2 2 1 1 2 2 1 1
p p d R R ancia MinimaDist
f p f p R F f R F f

donde F(R
1
) y F(R
2
) son los conjuntos de caras que forma los MBRs R
1
y R
2
,
respectivamente. Adems, f es una instancia de las caras que forman dichos conjuntos, y d es
la distancia Eucldea entre dos puntos definidos en E
(k)
.
A continuacin, damos una definicin algortmica a esta distancia que denominamos
MinMinDist.
Definicin. MinMinDist(R
1
, R
2
).
Dados dos MBRs R
1
= (s, t) y R
2
= (p, q) en E
(k)
, R
1
= (s, t), donde s = (s
1
, s
2
, ..., s
k
) y t = (t
1
,
t
2
, ..., t
k
) tal que s
i
t
i
, 1ik, R
2
= (p, q), donde p = (p
1
, p
2
, ..., p
k
) y q = (q
1
, q
2
, ..., q
k
) tal
que p
i
q
i
, 1ik, definimos MinMinDist(R
1
, R
2
) de la siguiente manera:

k
i
i
y R R MinMinDist
1
2
2 1
) , (
Consulta de los pares ms cercanos
77
donde,

'

>
<

casos otros los en


t p si t p
s q si q s
y
i i i i
i i i i
i
, 0
,
,

Debemos destacar que el clculo de MinMinDist(R
1
, R
2
) requiere slo un tiempo lineal
O(k), que depende del nmero de dimensiones.
La Figura 3.4 ilustra la mtrica MinMinDist(R
i
, R
j
) definida entre dos MBRs en E
(2)
.

R
1

R
2

R
3

R
4


Figura 3.4 MinMinDist(R
i
, R
j
) entre dos MBRs en E
(2)
.
Proposicin 3.1.
Dados dos MBRs R
1
= (s, t) y R
2
= (p, q) en E
(k)
, entonces se cumple que:
MinimaDistancia(R
1
, R
2
) = MinMinDist(R
1
, R
2
)
Demostracin:
Para demostrar esta igualdad debemos probar que MinMinDist(R
1
, R
2
) es la menor distancia
Eucldea que existe desde cualquier punto del permetro de R
1
a cualquier otro punto del
permetro de R
2
. Para ello, debemos estudiar el comportamiento de MinMinDist(R
1
, R
2
) en
cada una de las dimensiones 1ik, comprobando si R
1
y R
2
se solapan o no en cada
dimensin.
La distancia Eucldea desde cualquier punto del permetro de R
1
a cualquier otro punto del
permetro de R
2
, viene dada por la siguiente expresin:
i i i i i i i i
k
i
i i
q b p t a s : b a b a R R d

y , , ) , (
1
2
2 1

y nuestro objetivo es encontrar la expresin que minimiza d(R
1
, R
2
), es decir min{d(R
1
, R
2
)}.
Tambin, debemos tener en cuenta que dos MBRs se solapan si, y slo si comparten al menos
un punto en alguna de sus dimensiones. La instancia ms simple de un MBR ocurre en una
dimensin (k=1), donde los MBRs son intervalos. Debido a que un MBR en E
(k)
, es el
Captulo 3
78
producto cartesiano de k intervalos, paralelos a los diferentes ejes de coordenadas, el caso 1-
dimensional juega un papel fundamental a la hora de saber si dos MBRs se solapan o no.
Dos MBRs R
1
= (s, t) y R
2
= (p, q) en E
(k)
, se solapan si, y slo si existe una dimensin i tal
que: s
i
q
i
y p
i
t
i
. Considerando la negacin de la condicin anterior, dos MBRs R
1
= (s, t) y
R
2
= (p, q) en E
(k)
, no se solapan si, y slo si se verifica la siguiente condicin: s
i
> q
i
p
i
> t
i
,
1 i k.
Caso 1. R
1
y R
2
se solapan en la dimensin i.
La condicin de solape es, que existe al menos una dimensin i tal que s
i
q
i
y p
i
t
i
.
Adems, sabemos que cualquier punto del permetro de R
1
verifica que s
i
a
i
t
i
, y cualquier
punto del permetro de R
2
, p
i
b
i
q
i
. De todo ello obtenemos las siguientes condiciones: ((s
i

a
i
q
i
) y (p
i
a
i
t
i
)) o ((s
i
a
i
q
i
) y (p
i
a
i
t
i
)). Por tanto, existe al menos un par (a
i
, b
i
)
en el conjunto interseccin tal que a
i
= b
i
, entonces |a
i
b
i
| = 0. Obtenindose que, para la
distancia Eucldea desde cualquier punto del permetro de R
1
a cualquier otro punto del
permetro de R
2
, cuando los MBRs se solapan en una determinada dimensin i, entonces
dicha dimensin no interviene en el clculo de la distancia (valor 0). Por tanto,
MinimaDistancia(R
1
, R
2
) es 0 para esa dimensin i, igual que ocurre para MinMinDist(R
1
, R
2
).
Caso 2. R
1
y R
2
no se solapan en la dimensin i.
La condicin de no solape (disjuntos) es, s
i
> q
i
p
i
> t
i
, 1 i k. Adems, sabemos que
cualquier punto del permetro de R
1
verifica que s
i
a
i
t
i
, y cualquier punto del permetro de
R
2
, p
i
b
i
q
i
. De todo ello obtenemos las siguientes condiciones: ((q
i
< s
i
a
i
) o (a
i
t
i
<
p
i
)) y ((b
i
q
i
< s
i
) o (t
i
< p
i
b
i
)). Por tanto, tenemos que 1 i k: a
i
> b
i
o b
i
> a
i
,
entonces |a
i
b
i
| > 0. Obtenindose que, para la distancia Eucldea desde cualquier punto del
permetro de R
1
a cualquier otro punto del permetro de R
2
, cuando los MBRs no se solapan
en una determinada dimensin i, dicha dimensin s interviene en el clculo de la distancia.
Igual que ocurre para MinMinDist(R
1
, R
2
). El valor de min{d(R
1
, R
2
)} es min{|a
i
b
i
|} para
dimensin i.
Si s
i
> q
i
, entonces min{d(R
1
, R
2
)} = min{|a
i
b
i
|} = |s
i
q
i
|, igual que ocurre para
MinMinDist(R
1
, R
2
).
Si p
i
> t
i
, entonces min{d(R
1
, R
2
)} = min{|a
i
b
i
|} = |t
i
p
i
|, igual que ocurre para
MinMinDist(R
1
, R
2
).
Por tanto, de los resultados anteriores tenemos que min{d(R
1
, R
2
)} = MinMinDist(R
1
, R
2
).
Existen tres propiedades de MinMinDist que pueden enunciarse como los siguientes lemas.
La primera de ellas la denominamos propiedad de MinMinDist, y nos permite establecer una
generalizacin de la distancia entre los elementos (MBRs o puntos) que pueden constituir un
R*-tree.



Consulta de los pares ms cercanos
79
Lema 3.1. Propiedad de MinMinDist.
Dados dos MBRs R
1
= (s, t) y R
2
= (p, q) en E
(k)
,
1. Si s
i
= t
i
para R
1
= (s, t) y p
i
= q
i
para R
2
= (p, q), entonces los dos MBRs degeneran en
dos puntos s = (s
1
, s
2
, ..., s
k
) y p = (p
1
, p
2
, ..., p
k
), y por tanto MinMinDist(R
1
, R
2
) es
igual a la distancia Eucldea entre los puntos s y p.


k
i
i i
p s p s d
1
2
) , (
2. Si s
i
= t
i
para R
1
= (s, t), entonces este MBR degenera en un punto s = (s
1
, s
2
, ..., s
k
), y
por tanto MinMinDist(R
1
, R
2
) = MinDist(s, R
2
) [RKV95].
3. Si p
i
= q
i
para R
2
= (p, q), entonces este MBR degenera en un punto p = (p
1
, p
2
, ..., p
k
),
y por tanto MinMinDist(R
1
, R
2
) = MinDist(p, R
1
) [RKV95].
Demostracin:
Inmediata, considerando la definicin de MinMinDist entre dos MBRs, la distancia Eucldea
entre dos puntos y la distancia entre un punto y un MBR [RKV95].
La segunda propiedad est basada en la propiedad de la distancia en una dimensin y
establece que el valor de MinMinDist entre dos MBRs en una dimensin es menor o igual que
el valor de distancia de MinMinDist entre dos MBRs cuando intervienen todas las
dimensiones.
Lema 3.2. Propiedad de MinMinDist en una dimensin.
Dados dos MBRs R
1
= (s, t) y R
2
= (p, q) en E
(k)
, entonces el valor de MinMinDist(R
1
, R
2
) en
una dimensin determinada i (1ik) es siempre menor o igual que MinMinDist(R
1
, R
2
). Es
decir,
( ) ( ) k i R R MinMinDist i R R MinMinDist 1 , , , ,
2 1 2 1

donde
i
y i R R MinMinDist ) , , (
2 1
tal que

'

>
<

casos otros los en


t p si t p
s q si q s
y
i i i i
i i i i
i
, 0
,
,

Demostracin:
Inmediata, considerando la definicin de MinMinDist entre dos MBRs y la propiedad de la
distancia en una dimensin.
La Figura 3.5 ilustra esta propiedad de MinMinDist.
Captulo 3
80

MinMinDist(R
1
, R
2
, i)
R
1

R
1

R
2

MinMinDist(R
1
, R
2
)

Figura 3.5 Propiedad de MinMinDist en una dimensin en E
(2)
.
Otra propiedad importante de los MBRs almacenados en dos R*-trees relacionada con
MinMinDist la denominamos propiedad de MinMinDist sobre MBRs.
Lema 3.3. Propiedad de MinMinDist sobre MBRs.
Dados dos nodos internos N
P
y N
Q
(con MBRs M
P0
y M
Q0
) de dos R*-trees R
P
y R
Q
,
respectivamente. Estos dos nodos internos estn envolviendo dos conjuntos de MBRs {M
P1
,
M
P2
, , M
PA
} y {M
Q1
, M
Q2
, , M
QB
}. Entonces
MinMinDist(M
Pi
, M
Qj
) MinMinDist(M
P0
, M
Q0
): 1iA y 1jB
MinMinDist(M
P0
, M
Qj
) MinMinDist(M
P0
, M
Q0
): 1jB
MinMinDist(M
Pi
, M
Q0
) MinMinDist(M
P0
, M
Q0
): 1iA
Demostracin:
Inmediata, considerando la definicin de MinMinDist entre dos MBRs y la propiedad de
cubrimiento de MBRs en R*-trees.
Esta propiedad nos indica que la mnima distancia entre dos MBRs almacenados en dos
nodos internos N
P
y N
Q
(con MBRs M
P0
y M
Q0
) es siempre menor o igual que la mnima
distancia entre uno de los MBRs cubiertos por M
P0
y uno de los MBRs cubiertos por M
Q0
. La
Figura 3.6 ilustra esta propiedad de MinMinDist para A = B = 3.

M
P0

M
Q0

MinMinDist(M
P2
, M
Q2
)
M
P1

M
P3
M
P2

M
Q3

M
Q1

M
Q2

MinMinDist(M
P0
, M
Q0
)

Figura 3.6 Propiedad de MinMinDist sobre MBRs en E
(2)
.
Antes de continuar con las definiciones y propiedades aplicadas a objetos
multidimensionales almacenados en un R*-tree, debemos presentar el siguiente lema que
establece la propiedad de las caras de un MBR en un R*-tree [RKV95].
Consulta de los pares ms cercanos
81
Lema 3.4. Propiedad de las caras de un MBR en un R*-tree.
Cada cara (segmento de lnea en espacio bidimensional, MBR 2-dimensional en el espacio
tridimensional e MBR (k-1)-dimensional en E
(k)
), de un MBR en cualquier nivel, L del R*-
tree, comparte al menos un punto de algn objeto de la base de datos.
Demostracin:
Para demostrar este lema vamos a aplicar induccin sobre los niveles, L, del rbol de MBRs
R*-tree.
Para L = 0. Si estamos en el nivel de hojas (L = 0) del R*-tree (nivel donde estn almacenados
los MBRs que envuelven a los objetos). Suponemos por contradiccin, que una cara del MBR
de nivel 0 no comparte ningn punto de algn objeto de la base de datos. Entonces, por
definicin de MBR, existira un MBR ms pequeo cuyas caras s comparten algn punto de
dicho objeto, lo cual contradice la propia definicin de MBR a nivel de hojas (L = 0).
Suponemos que la condicin se satisface para cualquier MBR de nivel (L = i, siendo i 0), y
vamos a demostrar que se verifica para L = i + 1. Para ello, aplicando la definicin de R*-tree
que organiza MBRs como una estructura de datos arbrea multidimensional, donde cada
MBR en un nivel cualquiera (L = i + 1, siendo i 0) envuelve a varios MBRs del nivel
inferior (L = i, siendo i 0), compartiendo con cada una de sus caras al menos un punto de
algn objeto de la base de datos.
La Figura 3.7 muestra que cada cara del MBR en el nivel, L = i + 1 (lnea discontinua) est
compartiendo al menos un punto de algn objeto de la base de datos. La misma propiedad se
puede extender para los MBR en niveles superiores.

MBR de nivel L = i + 1
MBR de nivel L = i
MBR de nivel L = i

Figura 3.7 Propiedad de las caras de un MBR en un R*-tree.



Captulo 3
82
Definicin. Mnima distancia entre dos objetos en E
(k)
.
La distancia mnima entre dos objetos o
1
y o
2
, representada por ||(o
1
, o
2
)||, en E
(k)
, se define
como:
( ) ( )
2 2 1 1 2 1
1
2
2 1
,..., , y ,..., , , min ) , ( o y y y y o x x x x y x o o
k k
k
i
i i

'


De forma equivalente podemos definir esta misma distancia en funcin de las caras de los
objetos en E
(k)
de la siguiente forma.
Definicin. Mnima distancia entre dos objetos en E
(k)
en funcin de las caras de los mismos.
La mnima distancia en E
(k)
, entre dos objetos o
1
y o
2
caracterizados por sus conjuntos de
caras, la denotamos por ||(o
1
, o
2
)||, y viene dada por la siguiente expresin:
( ) { } { }
2 1 , ) ( ), ( 2 1
, min min ) , (
2 2 1 1 2 2 1 1
p p d o o
f p f p o F f o F f

donde F(o
1
) es el conjunto de caras que forman el objeto o
1
y F(o
2
) es el conjunto de caras
que forman el objeto o
2
en E
(k)
. Adems, f es una instancia de esas caras en cualquiera de los
anteriores conjuntos (F(o
1
) y F(o
2
)), y d es la funcin que determina la distancia Eucldea
entre dos puntos p
1
y p
2
definidos en E
(k)
, donde p
1
y p
2
es un par de puntos en alguna de las
caras de o
1
y o
2
, respectivamente.
Teorema 3.4.
Dados dos MBRs R
1
y R
2
en E
(k)
, definidos como R
1
= (s, t) y R
2
= (p, q), envolviendo a los
conjuntos de objetos en E
(k)
O
1
= {o
1i
, 1iN
1
} y O
2
= {o
2j
, 1jN
2
}, respectivamente.
Entonces para todo par de objetos (o
1i
, o
2j
) perteneciendo a O
1
O
2
se verifica que:
) , ( ) , (
2 1 2 1 j i
o o R R MinMinDist
Demostracin:
Inmediata, considerando las definiciones de MBR que envuelve un conjunto de objetos en E
(k)

(propiedad de las caras de un MBR en un R*-tree), de MinMinDist entre dos MBRs y, la
distancia entre dos objetos en E
(k)
.
La conclusin que se puede obtener de esta primera mtrica es que MinMinDist(R
1
, R
2
)
determina una cota inferior de la distancia Eucldea de cualquier par de objetos formado por
un objeto o
1i
O
1
incluido en R
1
y otro objeto o
2j
O
2
incluido en R
2
. Y es de utilidad para
evitar la visita de nodos innecesarios en el procesamiento de una consulta para obtener el par
ms cercano y su extensin para los K pares ms cercanos cuando tenemos dos conjuntos de
objetos indexados en sendos R*-trees.
La segunda mtrica entre dos MBRs (R
1
y R
2
) que vamos a introducir se denomina
MinMaxDist(R
1
, R
2
), y representa la mnima de todas las mximas distancias entre las caras
paralelas ms prximas de dos MBRs, R
1
y R
2
, para cada una de las dimensiones. sta es una
extensin de la definicin de MinMaxDist(p, R) hecha en [RKV95] entre un punto y un MBR,
pero aplicada entre dos MBRs definidos en E
(k)
.

Consulta de los pares ms cercanos
83
Definicin. MinimaMaximaDistancia(R
1
, R
2
).
El mnimo valor de todas las mximas distancias entre los puntos que forman las caras de
dos MBRs, R
1
y R
2
, definidos en E
(k)
, denotado como MinimaMaximaDistancia(R
1
, R
2
), se
define como:
( ) ( ) { } { }
2 1 , ) ( ), ( 2 1
, max min ,
2 2 1 1 2 2 1 1
p p d R R a maDistanci MinimaMaxi
f p f p R F f R F f

donde F(R
1
) y F(R
2
) son los conjuntos de caras que forma los MBRs R
1
y R
2
,
respectivamente. Adems, f es una instancia de las caras que forman dichos conjuntos, y d es
la distancia Eucldea entre dos puntos p
1
y p
2
, definidos en E
(k)
, donde p
1
y p
2
es un par de
puntos en alguna de las caras de R
1
y R
2
, respectivamente.
La Figura 3.8 ilustra la mtrica MinimaMaximaDistancia(R
i
, R
j
) definida entre dos MBRs.

R
1

R
2

R
3

R
4


Figura 3.8 MinimaMaximaDistancia(R
i
, R
j
) entre dos MBRs en E
(2)
.
Como ejemplo, vamos a estudiar la forma de calcular MinimaMaximaDistancia(R
1
, R
2
) en
E
(2)
, como se ilustra en la Figura 3.9. En este espacio debemos destacar que las caras de los
MBRs son segmentos de lnea (MBRs 1-dimensionales).

b
4

b
3

b
2

b
1

a
4

a
3

a
2

a
1

(t
1
, t
2
)
d
d
d
d
(s
1
, s
2
)
(p
1
, p
2
)
(q
1
, q
2
)
R
1

R
2


Figura 3.9 Distancias entre las caras a
1
y b
1
para calcular MinimaMaximaDistancia(R
1
, R
2
).
Captulo 3
84
Sean a
1
, a
2
, a
3
, a
4
y b
1
, b
2
, b
3
y b
4
, las cuatro caras (aristas en E
(2)
) de los MBRs R
1
y R
2
,
respectivamente. A nivel de puntos, tenemos la siguiente definicin de las caras: a
1
= {(s
1
, s
2
),
(s
1
, t
2
)}, a
2
= {(s
1
, s
2
), (t
1
, s
2
)}, a
3
= {(t
1
, t
2
), (t
1
, s
2
)} y a
4
= {(t
1
, t
2
), (s
1
, t
2
)} para el MBR R
1
, y
b
1
= {(p
1
, p
2
), (p
1
, q
2
)}, b
2
= {(p
1
, p
2
), (q
1
, p
2
)}, b
3
= {(q
1
, q
2
), (q
1
, p
2
)} y b
4
= {(q
1
, q
2
), (p
1
,
q
2
)} para el MBR R
2
.
Denotamos como MAXIMADISTANCIA(a
i
, b
i
) a la mxima distancia Eucldea d entre los
puntos que delimitan las caras a
i
y b
i
, siendo 1i4. Es decir,
( ) ( ) { }
( ) 2
n ,
, , max , E en 4 i 1 p p d b a ANCIA MAXIMADIST
m b p a p i i
i n i m



Una vez calculadas todas las mximas posibles distancias entre las caras de los dos MBRs
obtenemos la menor de ellas como valor de MinimaMaximaDistancia(R
1
, R
2
).
A continuacin vamos a exponer el algoritmo para calcular MinimaMaximaDistancia(R
1
,
R
2
) en E
(2)
.
MinimaMaximaDistancia(R
1
: MBR, R
2
: MBR)
01 MINIMAMAXIMADISTANCIA = ;
02 A = conjuntoCaras(R
1
) = {a
1
, a
2
, a
3
, a
4
}; // Conjunto de 4 (2k) caras del MBR R
1

03 B = conjuntoCaras(R
2
)= {b
1
, b
2
, b
3
, b
4
}; // Conjunto de 4 (2k) caras del MBR R
2

04 i = 1;
05 while (i 4) do
06 j = 1;
07 while (j 4) do
08 MAXIMADISTANCIA = ;
09 m = 1;
10 while (m 2) do
11 n = 1;
12 while (n 2) do
13 dist = d(p
m
a
i
, p
n
b
j
);
14 if (dist > MAXIMADISTANCIA) then
15 MAXIMADISTANCIA = dist;
16 endif
17 n = n + 1;
18 enddo
19 m = m + 1;
20 enddo
21 if (MAXIMADISTANCIA < MINIMAMAXIMADISTANCIA) then
22 MINIMAMAXIMADISTANCIA = MAXIMADISTANCIA;
23 endif
24 j = j + 1;
25 enddo
26 i = i + 1;
27 enddo
28 return MINIMAMAXIMADISTANCIA;
Para generalizar el algoritmo en E
(k)
, debemos tener en cuenta las siguientes propiedades:
1. Un MBR en E
(k)
tiene 2k caras [Oro98], siendo cada una de ellas un MBR de dimensin
k 1. A = {a
1
, a
2
, ..., a
2k
} para el MBR R
1
y B = {b
1
, b
2
, ..., b
2k
} para el MBR R
2
, son
sus respectivos conjuntos de caras.
Consulta de los pares ms cercanos
85
2. Si cada MBR en E
(k)
tiene 2
k
puntos [Oro98], entonces cada cara (a
i
) de dimensin k 1
tendr 2
k-1
puntos. Adems, cada punto tendr k coordenadas, p = (p
1
, p
2
, ..., p
k
).
El algoritmo general para calcular MinimaMaximaDistancia(R
1
, R
2
) en E
(k)
es el que se
muestra a continuacin.
MinimaMaximaDistancia(R
1
: MBR, R
2
: MBR)
01 MINIMAMAXIMADISTANCIA = ;
02 A = conjuntoCaras(R
1
) = {a
1
, a
2
, ..., a
2k
}; // Conjunto de 2k caras del MBR R
1

03 B = conjuntoCaras(R
2
) = {b
1
, b
2
, ..., b
2k
}; // Conjunto de 2k caras del MBR R
2

04 i = 1;
05 while (i 2k) do
06 j = 1;
07 while (j 2k) do
08 MAXIMADISTANCIA = ;
09 m = 1;
10 while (m 2
k-1
) do
11 n = 1;
12 while (n 2
k-1
) do
13 dist = d(p
m
a
i
, p
n
b
j
);
14 if (dist > MAXIMADISTANCIA) then
15 MAXIMADISTANCIA = dist;
16 endif
17 n = n + 1;
18 enddo
19 m = m + 1;
20 enddo
21 if (MAXIMADISTANCIA < MINIMAMAXIMADISTANCIA) then
22 MINIMAMAXIMADISTANCIA = MAXIMADISTANCIA;
23 endif
24 j = j + 1;
25 enddo
26 i = i + 1;
27 enddo
28 return MINIMAMAXIMADISTANCIA;
Debemos destacar que el proceso para calcular el conjunto de caras que tiene cada MBR
(2k caras) depende de su estructura (R = (s, t), donde s = (s
1
, s
2
, ..., s
k
) y t = (t
1
, t
2
, ..., t
k
), s
i
t
i

para todo 1ik), y se realiza combinando los elementos s
i
y t
i
en sus k 1 posibles
posiciones para obtener los 2
k-1
puntos por cara. Adems, d es la funcin que determina la
distancia entre dos puntos p
m
y p
n
definidos en E
(k)
. El algoritmo anterior tiene orden
exponencial O(2
k
), dependiendo de la dimensionalidad de E
(k)
. Por lo tanto el coste de clculo
para la mtrica MinimaMaximaDistancia(R
1
, R
2
) es muy elevado, sobre todo cuando la
dimensin k4.
Debido a que el clculo de MinimaMaximaDistancia(R
1
, R
2
) tiene un coste exponencial
vamos a dar una aproximacin de sta que necesite slo un coste lineal y que denotaremos
como MinMaxDist(R
1
, R
2
) entre dos MBRs, R
1
y R
2
, definidos en E
(k)
. Esta mtrica representa
la mnima de todas las mximas distancias entre las caras paralelas ms prximas de los dos
MBRs para cada una de las k dimensiones.

Captulo 3
86
Definicin. MinMaxDist(R
1
, R
2
).
El mnimo valor de todas las mximas distancias entre los puntos que forman las caras
paralelas ms prximas de dos MBRs R
1
= (s, t) y R
2
= (p, q) en E
(k)
, R
1
= (s, t), donde s =
(s
1
, s
2
, ..., s
k
) y t = (t
1
, t
2
, ..., t
k
) tal que s
i
t
i
, 1ik, R
2
= (p, q), donde p = (p
1
, p
2
, ..., p
k
) y q
= (q
1
, q
2
, ..., q
k
) tal que p
i
q
i
, 1ik, la denominamos MinMaxDist(R
1
, R
2
), y la definimos
de la siguiente manera:

'

+



k
j i i
i j
k j
y x R R MinMaxDist
, 1
2 2
1
2 1
min ) , ( ; donde
{ }
j j j j j j j j j
q t p t q s p s x , , , min e { }
i i i i i
p t q s y , max
La frmula


+ +
k
i
i j j
k
j i i
i j
y y x y x
1
2 2 2
, 1
2 2
, donde { } ( )
j j j j j
p t q s y , max
expresa la mxima distancia entre las caras paralelas ms prximas en la dimensin j. Por
tanto, MinMaxDist(R
1
, R
2
) ser el mnimo valor de todas las distancias de dicha frmula para
las k dimensiones.
Para el clculo de MinMaxDist(R
1
, R
2
), la expresin

k
i
i
y
1
2

se calcula slo una vez, devolviendo la distancia entre los vrtices ms lejanos de dos MBRs
(mxima distancia entre vrtices), en un tiempo O(k). Despus, se calcula x
j
2
y
j
2
(para todos
los valores de j, 1jk) en un tiempo tambin O(k), donde se anula para esa dimensin j la
mxima distancia y
j
, y se sustituye en esa dimensin (j) por el menor valor de distancia entre
las caras de los dos MBRs x
j
(caras ms cercanas para los dos MBRs). Por tanto, el clculo de
MinMaxDist(R
1
, R
2
) se determina en un tiempo O(k).
Proposicin 3.2.
Dados dos MBRs R
1
= (s, t) y R
2
= (p, q) en E
(k)
, la siguiente propiedad es cierta:
) , ( ) , (
2 1 2 1
R R MinMaxDist R R a maDistanci MinimaMaxi
Demostracin:
Inmediata, ya que el conjunto de caras procesado por MinimaMaximaDistancia(R
1
, R
2
) es
siempre mayor que el procesado al calcular MinMaxDist(R
1
, R
2
).
Esta proposicin nos dice que MinMaxDist(R
1
, R
2
) es una buena aproximacin para
determinar una cota superior de la distancia del par ms cercano, ya que siempre
MinMaxDist(R
1
, R
2
) MinimaMaximaDistancia(R
1
, R
2
). Es decir, el valor de MinMaxDist(R
1
,
R
2
) siempre ser mayor o igual que la distancia del par ms cercano.
Consulta de los pares ms cercanos
87
La principal ventaja de MinMaxDist(R
1
, R
2
) sobre MinimaMaximaDistancia(R
1
, R
2
) es que
su clculo se realiza en tiempo lineal O(k), mientras que para MinimaMaximaDistancia(R
1
,
R
2
) se necesita un tiempo exponencial O(2
k
), haciendo a esta ltima impracticable cuando
tenemos un nmero de dimensiones grande (k4).
En la Figura 3.10 podemos observar el valor de MinimaMaximaDistancia(R
1
, R
2
) y las
distancias candidatas para obtener MinMaxDist(R
1
, R
2
) sobre cada una de las dimensiones en
E
(2)
. De esta figura es evidente que MinimaMaximaDistancia(R
1
, R
2
) < MinMaxDist(R
1
, R
2
).
Por ejemplo, si en la dimensin X (k = 1) de R
1
el intervalo [s
1
, t
1
] fuese ms grande,
haciendo que s
1
sea cada vez menor mientras que t
1
sigue fijo, llegara un momento en que
MinimaMaximaDistancia(R
1
, R
2
) = MinMaxDist(R
1
, R
2
), y despus
MinimaMaximaDistancia(R
1
, R
2
) ser siempre el valor determinado previamente con
MinMaxDist(R
1
, R
2
).

R
2

R
1

MinimaMaximaDistancia
Candidatas a MinMaxDist
MinMaxDist

Figura 3.10 MinimaMaximaDistancia(R
1
, R
2
) y MinMaxDist(R
1
, R
2
) entre dos MBRs en E
(2)
.
Teorema 3.5.
Dado dos MBRs R
1
y R
2
en E
(k)
, definidos como R
1
= (s, t) y R
2
= (p, q) envolviendo a los
conjuntos de objetos en E
(k)
O
1
= {o
1i
, 1iN
1
} y O
2
= {o
2j
, 1jN
2
}, respectivamente.
Entonces existe al menos un par de objetos (o
1i
, o
2j
) perteneciendo a O
1
O
2
que verifica:
) , ( ) , (
2 1 2 1
R R MinMaxDist o o
j i

Demostracin:
Inmediata, considerando las definiciones de MBR que envuelve un objeto en E
(k)
(propiedad
de las caras de un MBR en un R*-tree), de MinMaxDist entre dos MBRs y, la distancia entre
dos objetos en E
(k)
.
Segn el teorema 3.5, MinMaxDist(R
1
, R
2
) es una buena distancia como cota superior para
el par ms cercano, ya que nos garantiza la presencia del par de objetos en E
(k)
(o
1i
, o
2j
) ms
cercano, compartiendo al menos un punto de los MBR R
1
y R
2
. Adems, sta es apropiada
cuando tenemos dimensiones grandes (k4), puesto que su clculo tiene coste lineal O(k).
La ltima mtrica entre pares de MBRs que vamos a introducir es MaxMaxDist(R
1
, R
2
),
que representa la distancia entre los vrtices ms lejanos de los MBRs R
1
y R
2
.
Captulo 3
88
MaxMaxDist(R
1
, R
2
) nos garantiza que en esa distancia van a estar todos los posibles pares de
objetos que se pueden formar, estando incluidos en los MBRs R
1
y R
2
. Por tanto, esta mtrica
nos proporciona una cota superior para los K pares ms cercanos.
Definicin. MaximaDistancia(R
1
, R
2
).
El mximo valor de todas las mximas distancias entre los puntos que forman las caras de
dos MBRs, R
1
y R
2
, definidos en E
(k)
, denotado como MaximaDistancia(R
1
, R
2
), se define
como:
( ) ( ) { } { }
2 1 , ) ( ), ( 2 1
, max max ,
2 2 1 1 2 2 1 1
p p d R R ancia MaximaDist
f p f p R F f R F f

donde F(R
1
) y F(R
2
) son los conjuntos de caras que forma los MBRs R
1
y R
2
,
respectivamente. Adems, f es una instancia de las caras que forman dichos conjuntos, y d es
la distancia Eucldea entre dos puntos p
1
y p
2
, definidos en E
(k)
, donde p
1
y p
2
es un par de
puntos en alguna de las caras de R
1
y R
2
, respectivamente.
A continuacin presentamos una definicin algortmica de esta distancia.
Definicin. MaxMaxDist(R
1
, R
2
).
Dados dos MBRs R
1
= (s, t) y R
2
= (p, q) en E
(k)
, R
1
= (s, t), donde s = (s
1
, s
2
, ..., s
k
) y t = (t
1
,
t
2
, ..., t
k
) tal que s
i
t
i
, 1ik, R
2
= (p, q), donde p = (p
1
, p
2
, ..., p
k
) y q = (q
1
, q
2
, ..., q
k
) tal
que p
i
q
i
, 1ik, definimos MaxMaxDist(R
1
, R
2
) de la siguiente manera:

k
i
i
y R R MaxMaxDist
1
2
2 1
) , ( ; donde, { }
i i i i i
p t q s y , max
La Figura 3.11 ilustra la mtrica MaxMaxDist(R
i
, R
j
) definida entre dos MBRs.

R
1

R
2

R
3

R
4


Figura. 3.11 MaxMaxDist(R
i
, R
j
) entre dos MBRs en E
(2)
.
Proposicin 3.3.
Dados dos MBRs R
1
= (s, t) y R
2
= (p, q) en E
(k)
, la siguiente propiedad es cierta:
MaximaDistancia(R
1
, R
2
) = MaxMaxDist(R
1
, R
2
)
Demostracin:
Consulta de los pares ms cercanos
89
Para demostrar esta igualdad debemos probar que MaxMaxDist(R
1
, R
2
) es la mayor distancia
Eucldea que existe desde cualquier punto del permetro de R
1
a cualquier otro punto del
permetro de R
2
.
Sabemos que la distancia Eucldea desde cualquier punto del permetro de R
1
a cualquier otro
punto del permetro de R
2
, viene dada por la siguiente expresin:
i i i i i i i i
k
i
i i
q b p t a s : b a b a R R d

y , , ) , (
1
2
2 1

El objetivo es maximizar |a
i
b
i
| para cada una de las dimensiones 1ik (max{|a
i
b
i
|}). Para
ello, consideramos el punto medio de los intervalos que intervienen en cada dimensin: [s
i
, t
i
]
tal que s
i
t
i
, 1ik; (s
i
+ t
i
)/2, y [p
i
, q
i
] tal que p
i
q
i
, 1ik; (p
i
+ q
i
)/2.
Si (s
i
+ t
i
)/2 (p
i
+ q
i
)/2, entonces el mayor componente del intervalo con el punto
medio ms lejano es q
i
, y el menor componente del intervalo con el punto medio ms
cercano es s
i
, independientemente si los intervalos [s
i
, t
i
] y [p
i
, q
i
] se solapan o no. Por
tanto, max{|a
i
b
i
|} = |s
i
q
i
|.
Si por el contrario, (s
i
+ t
i
)/2 > (p
i
+ q
i
)/2, entonces el mayor componente del intervalo
con el punto medio ms lejano es t
i
, y el menor componente del intervalo con el punto
medio ms cercano es p
i
, independientemente si los intervalos [s
i
, t
i
] y [p
i
, q
i
] se solapan
o no. Por tanto, max{|a
i
b
i
|} = |t
i
p
i
|.
Teorema 3.6.
Dados dos MBRs R
1
y R
2
de dos R*-trees en E
(k)
, definidos como R
1
= (s, t) y R
2
= (p, q),
envolviendo a los conjuntos de objetos en E
(k)
O
1
= {o
1i
, 1iN
1
} y O
2
= {o
2j
, 1jN
2
},
respectivamente. Entonces para todo par de objetos (o
1i
, o
2j
) perteneciendo a O
1
O
2
se
verifica que:
) , ( ) , (
2 1 2 1
R R MaxMaxDist o o
j i

Demostracin:
Inmediata, considerando las definiciones de MBR que envuelve un objeto en E
(k)
(propiedad
de las caras de un MBR en un R*-tree), de MaxMaxDist entre dos MBRs y de la distancia
entre dos objetos en E
(k)
.
La conclusin que se puede obtener de esta ltima mtrica es que MaxMaxDist(R
1
, R
2
)
determina una cota superior de la distancia Eucldea de cualquier par de objetos formado por
un objeto o
1i
O
1
incluido en R
1
y otro objeto o
2j
O
2
incluido en R
2
. Adems, MaxMaxDist
es de utilidad para evitar la visita de nodos innecesarios en el procesamiento de una consulta
para obtener los K pares ms cercanos. Para concluir, enunciamos la relacin existente entre
MinMinDist, MaxMaxDist y la distancia entre dos objetos o
1
y o
2
caracterizados por sus
conjuntos de caras, en forma de corolario


Captulo 3
90
Corolario 3.1.
Dados dos MBRs R
1
y R
2
de dos R*-trees en E
(k)
, definidos como R
1
= (s, t) y R
2
= (s, t)
envolviendo a los conjuntos de objetos en E
(k)
O
1
= {o
1i
, 1iN
1
} y O
2
= {o
2j
, 1jN
2
},
respectivamente. Entonces para cualquier par de objetos (o
1i
, o
2j
) perteneciendo a O
1
O
2
se
verifica que:
2 1 2 1 2 1 2 1 2 1
) , ( ), , ( ) , ( ) , ( O O o o R R MaxMaxDist o o R R MinMinDist
j i j i

Demostracin:
La demostracin es inmediata segn los teoremas 3.4 y 3.6.
Para finalizar con las mtricas entre pares de MBRs definidos en E
(k)
, que se van a utilizar
en el desarrollo de los algoritmos branch-and-bound para resolver el problema del par ms
cercano y su extensin para los K pares ms cercanos, vamos a ilustrarlas en la Figura 3.12.

R
1

R
2

MinMinDist
MinMaxDist
MaxMaxDist

Figura 3.12 MinMinDist, MinMaxDist y MaxMaxDist entre dos MBRs R
1
y R
2
en E
(2)
.
Las mtricas entre pares de MBRs MinMinDist(R
1
, R
2
) y MinMaxDist(R
1
, R
2
) se utilizan en
reglas de poda basadas en los teoremas 3.4 y 3.5, y aplicadas en los nodos de los R*-trees
cuando se recorren simultneamente desde la raz hasta las hojas segn un algoritmo branch-
and-bound para encontrar el par ms cercano. Por otro lado, las mtricas entre pares de
MBRs MinMinDist(R
1
, R
2
) y MaxMaxDist(R
1
, R
2
) se utilizan en unas reglas de poda similares
(teoremas 3.4 y 3.6) para encontrar los K pares ms cercanos utilizando el mismo tipo de
algoritmo.

3.5 Conclusiones

En este captulo hemos definido las mtricas en E
(k)
entre pares de MBRs y establecido sus
propiedades, que nos servirn para disear algoritmos branch-and-bound que respondan a las
consultas de los pares ms cercanos de dos conjuntos de objetos indexados en sendos R*-
trees. Para ello, establecemos los conceptos mtricos necesarios, definimos dichas consultas y
Consulta de los pares ms cercanos
91
planteamos ejemplos de aplicacin de las mismas en el campo de las bases de datos
espaciales. Tambin, presentamos la relacin que existe entre la consulta del vecino ms
prximo y el join espacial con la consulta de los pares ms cercanos, revisando las mtricas en
E
(k)
entre un punto y un MBR, sus propiedades y las heursticas de poda aplicadas a R*-trees.
El diseo de algoritmos branch-and-bound eficientes aplicados sobre mtodos de
indexacin arbreos basados en MBRs, requiere de la definicin (conceptual y algortmica),
anlisis e implementacin de mtricas entre pares de MBRs para aplicarlas en heursticas de
poda sobre dichos ndices y dar respuesta a consultas de los pares ms cercanos. Las mtricas
originales presentadas en este captulo han sido: (1) MinMinDist(R
1
, R
2
), que representa la
mnima distancia en E
(k)
que hay entre dos MBRs, R
1
y R
2
, y se utiliza como cota inferior de
la distancia de todos los pares ms cercanos de objetos que contienen dichos MBRs; (2)
MinMaxDist(R
1
, R
2
), que nos devuelve la mnima de todas las mximas distancias en E
(k)

entre las caras paralelas ms prximas de dos MBRs, R
1
y R
2
, en cada una de las dimensiones,
y se emplea como cota superior de la distancia del par ms cercano de objetos que envuelven
dichos MBRs; y (3) MaxMaxDist(R
1
, R
2
), que representa la mxima distancia en E
(k)
que hay
entre dos MBRs, R
1
y R
2
, y se utiliza como cota superior de la distancia de todos pares ms
cercanos de objetos que contienen dichos MBRs.


93


Captulo 4


ALGORITMOS PARA LA
REALIZACIN DE LA CONSULTA
DEL PAR MS CERCANO
UTILIZANDO R*-TREES



4.1 Introduccin

La tcnica branch-and-bound se utiliza con mucha frecuencia para buscar la solucin ptima
de un determinado problema al recorrer un rbol explcito o implcito. La idea principal de un
algoritmo branch-and-bound es dividir un determinado problema inicial en un nmero de
subproblemas parciales de tamao ms pequeo. Cada subproblema est caracterizado por la
inclusin de una o ms restricciones para descartar posibles subproblemas que no conduzcan a
la solucin ptima. El proceso de descomposicin se aplica repetidamente a los subproblemas
generados, hasta que cada uno de los subproblemas no examinados se vuelve a descomponer,
se resuelve, o indica que no va a conducir a la solucin ptima del problema inicial. Nosotros
utilizaremos branch-and-bound para encontrar el par ms cercano de dos conjunto de objetos
almacenados en sendos R*-trees. Para disear algoritmos branch-and-bound sobre R*-trees
debemos aplicar una funcin de seleccin que no afecta a la convergencia del algoritmo pero
s a su eficiencia y a los recursos requeridos. Las funciones de seleccin ms comunes son:
bsqueda en profundidad (recorrido en profundidad del rbol), bsqueda en anchura
(recorrido en anchura del rbol), primero el mejor (selecciona siempre el menor valor de una
funcin) y el esquema hbrido (combina un recorrido en anchura con una estrategia de
seleccin de primero el mejor).
Captulo 4
94
En este captulo veremos una serie de algoritmos para dar respuesta a la consulta del par
ms cercano utilizando como mtodo de indexacin los R*-trees [BKS
+
90], es decir, los dos
conjuntos de objetos van a estar indexados por sendos R*-trees. Empezaremos con las
aproximaciones algortmicas ms intuitivas para dar solucin a dicha consulta. La primera de
ellas consiste en realizar una combinacin de un recorrido en profundidad en uno de los R*-
trees con una consulta del vecino ms prximo sobre el otro R*-tree. La segunda es
consecuencia directa del join sobre ndices siguiendo un esquema de bucle anidado. La tercera
aproximacin es un algoritmo iterativo que utiliza un montculo para evitar la recursividad.
Despus de establecer estas primeras aproximaciones se presentan una serie de algoritmos
branch-and-bound, para las variantes recursivas e iterativas, que utilizan unas mtricas entre
pares de MBRs como cotas durante el recorrido del rbol y diferentes criterios de seleccin de
nodos, con el objetivo de obtener resultados ptimos del coste de dicha consulta. Para mejorar
an ms estos algoritmos, se presentan tcnicas de optimizacin para reducir el nmero de
accesos a disco y el tiempo de respuesta.

4.2 Primeras aproximaciones para dar solucin a la
consulta del par ms cercano utilizando R*-trees

Para establecer los primeros algoritmos que nos devuelvan como resultado el par ms cercano
debemos recordar cmo recorrer un R*-tree tanto en profundidad como en anchura.
Posteriormente estudiaremos la primera aproximacin, que consiste en una combinacin de
un recorrido en profundidad en el primero de los R*-trees con una consulta del vecino ms
prximo sobre el segundo R*-tree, teniendo como elemento de consulta los objetos
almacenados en las hojas del primero. A continuacin veremos la segunda aproximacin
basada en el join espacial propuesto en [BKS93a] que sigue un esquema en bucle anidado, sin
utilizar ninguna mtrica como mecanismo de poda. Y por ltimo, se presenta la versin
iterativa (no recursiva) utilizando un montculo para obtener la solucin a la consulta del par
ms cercano, utilizando una funcin basada en niveles para organizar el montculo y ninguna
mtrica entre pares de MBRs como mecanismo de poda.

4.2.1 Recorridos de un R*-tree

En los dos siguientes apartados vamos a recordar cmo se realiza un recorrido en profundidad
de un R*-tree, as como el recorrido en anchura utilizando estructuras de datos adicionales,
con el objetivo de establecer la base para los algoritmos que determinan el par ms cercano.


Algoritmos para la realizacin de la consulta del par ms cercano utilizando R*-trees
95
4.2.1.1 Recorrido en profundidad de un R*-tree

Para efectuar el recorrido en profundidad de un R*-tree, se selecciona la raz como punto de
partida. A continuacin, si hay un nodo hijo adyacente a dicha raz que no haya sido visitado
todava, se toma este nuevo nodo como punto de partida y se llama recursivamente al
algoritmo. Al volver de la llamada recursiva, si hay otro nodo hijo adyacente a la raz que no
haya sido visitado, se toma este nodo hijo como punto de partida siguiente, se vuelve a llamar
recursivamente al algoritmo, y as sucesivamente. Si se han visitado todos los nodos del rbol,
el recorrido que comenzaba en la raz, ha finalizado.
El esquema general del algoritmo recursivo de recorrido en profundidad de un rbol tipo
R*-tree (sin distinguir tipos de nodos) siguiendo un esquema preorden, lo podemos ver a
continuacin:
Recorrido_Profundidad(N: R_nodo)
01 if N no es nulo then
02 for every entrada n
i
de N do
03 N = LeerNodo(n
i
.direccion);
04 Recorrido_Profundidad(N);
05 enddo
06 endif
El algoritmo se llama de recorrido en profundidad porque inicia tantas llamadas recursivas
como sea posible antes de volver de una llamada. La recursividad slo se detiene cuando la
exploracin del rbol se ve bloqueada o no puede proseguir. En dicho momento, la
recursividad retrocede (fase de backtracking o vuelta atrs) para que sea posible estudiar
posibles alternativas en niveles ms elevados del rbol.
El tiempo que necesita el algoritmo para explorar un rbol en el que hay N nodos (internos
y hojas), dado que cada nodo se visita exactamente una vez y hay N llamadas recursivas al
algoritmo Recorrido_Profundidad, est en O(N), como se puede comprobar en [Knu86,
BrB97, Seg98].

4.2.1.2 Recorrido en anchura de un R*-tree

Cuando un recorrido en anchura de un R*-tree llega a algn nodo, primero visita todos los
hijos de dicho nodo, y slo examina nodos en niveles ms bajos despus de haber visitado a
todos los del nivel actual. A diferencia del recorrido en profundidad, el recorrido en anchura
no es recursivo. Para ello, se utiliza una estructura de datos cola (Q) por niveles (segn la
altura del rbol), que es una lista de elementos a manejar segn el orden primero en llegar,
primero en salir (FIFO) por cada nivel. Esta cola por niveles admite cinco operaciones:
crearCola (crea la estructura de datos cola segn la altura del rbol a recorrer), destruirCola
(destruye la estructura de datos cola), estaVacia (detecta si la estructura de datos cola est
vaca en un nivel determinado), ponerElemento (coloca un nuevo elemento al final de la
Captulo 4
96
estructura de datos cola, determinada por el nivel que se le pasa como parmetro) y
quitarElemento (elimina el elemento situado al principio de la estructura de datos cola,
indicada por el nivel pasado como parmetro). A continuacin detallamos el algoritmo para el
recorrido en anchura de un rbol tipo R*-tree.
Recorrido_Anchura(Raiz: R_nodo; Altura: Entero)
01 Q.crearCola(Altura);
02 Q.ponerElemento(Altura 1, Raiz);
03 nivel = Altura 1;
04 while (nivel > 0) do
05 while not Q.estaVacia(nivel) do
06 N = Q.quitarElemento(nivel);
07 for every entrada n
i
de N do
08 N = LeerNodo(n
i
.direccion);
09 Q.ponerElemento(nivel 1, N);
10 enddo
11 enddo
12 nivel = nivel 1;
13 enddo
14 Q.destruirCola();
El tiempo requerido por un recorrido en anchura de un rbol con N nodos (internos y
hojas), dado que cada nodo se visita exactamente una vez, est en O(N). Al igual que le
ocurra al recorrido en profundidad.

4.2.2 Algoritmo que combina un recorrido de un R*-tree con una
consulta del vecino ms prximo sobre el otro R*-tree

La primera aproximacin que intuitivamente pensamos cuando deseamos encontrar el par ms
cercano es realizar una combinacin de un recorrido (en profundidad o en anchura) en uno de
los R*-trees con la consulta del vecino ms prximo sobre el otro R*-tree, teniendo como
elemento de consulta a los objetos almacenados en las hojas del primero. Una vez encontrados
todos los vecinos ms prximos de cada uno de los objetos del primer R*-tree obtenemos el
par ms cercano como aqul que presenta la menor distancia.
Para obtener el par ms cercano debemos mantener un par de objetos a nivel global y la
distancia entre ellos procesada hasta el momento, parMasCercano. De manera que si
obtenemos un par de objetos con una distancia entre ellos menor que la del parMasCercano
encontrado hasta el momento, entonces lo actualizamos como el nuevo par ms cercano.
Como ejemplo de esta primera aproximacin veremos la combinacin del recorrido en
profundidad siguiendo el esquema de Recorrido_Profundidad, y para la consulta del vecino
ms prximo podemos utilizar CVP_Recursivo [RKV95]. El par ms cercano requerido es el
que se corresponde con el valor final de distancia para parMasCercano, siendo el esquema
general del algoritmo el que se muestra a continuacin:

Algoritmos para la realizacin de la consulta del par ms cercano utilizando R*-trees
97
CPC_Recorrido_Profundidad_CVP(nP, nQ: R_nodo; parMasCercano: ParObjetos)
01 if nP es un nodo INTERNO then
02 for every entrada p
i
de nP do
03 nP = LeerNodo(p
i
.direccion);
04 CPC_Recorrido_Profundidad_CVP(nP, nQ, parMasCercano);
05 enddo
06 else
07 for every entrada p
i
de nP do
08 distVP = ;
09 CVP_Recursivo(nQ, p
i
, VP, distVP);
10 if distVP parMasCercano.distancia then
11 parMasCercano.distancia = distVP;
12 parMasCercano.parObjetos = (p
i
, VP);
13 endif
14 enddo
15 endif
Como sabemos, el tiempo que necesita el algoritmo para recorrer en profundidad el R*-tree
R
P
en el que hay N nodos est en O(N). Adems, en el peor caso, CVP_Recursivo sobre el
R*-tree R
Q
en el que hay M nodos est tambin en O(M). Por tanto, el tiempo del algoritmo
CPC_Recorrido_Profundidad_CVP, en el peor caso, est en O(N * M).

4.2.3 Algoritmo recursivo siguiendo un esquema de join en bucle
anidado sobre dos R*-trees

Esta segunda aproximacin sigue el mismo esquema que el algoritmo presentado en
[BKS93a] para la solucin del join espacial segn el predicado solapa, que a su vez es un join
(recorrido en profundidad) en bucle anidado sobre ndices, ya que se dispone de un ndice
(R*-tree) para el atributo espacial de ambos conjuntos de objetos espaciales.
Este algoritmo consiste en dos bucles for anidados sobre los dos ndices R*-trees, donde
R
P
es el ndice externo y R
Q
es el interno. Este esquema es muy costoso, ya que para obtener
el resultado requerido es preciso examinar cada pareja de objetos almacenados en las hojas de
ambos R*-trees. Adems, para cada objeto de R
P
se tiene que realizar una exploracin
completa en el ndice de R
Q
.
Para obtener el par ms cercano de objetos con este algoritmo debemos mantener tambin
un par de objetos a nivel global (parMasCercano.parObjetos) y la distancia entre ellos
procesada hasta el momento (parMasCercano.distancia). De manera que si obtenemos un par
de objetos con una distancia entre ellos menor que la de parMasCercano, entonces lo
actualizamos con dicho valor. El siguiente esquema por pasos (CPCR#) muestra esta segunda
aproximacin para obtener el par ms cercano de objetos indexados en dos R*-trees con la
misma altura y almacenando los objetos (puntos) en las hojas. Al algoritmo correspondiente le
denominamos CPC_Recursivo_Fuerza_Bruta.
CPCR1 Comenzar por las races de los dos R*-trees y fijar la distancia del par ms
cercano encontrado hasta el momento, parMasCercano.distancia, a infinito ().
Captulo 4
98
CPCR2 Si se accede a un par de nodos internos (nP y nQ), propagar hacia abajo
recursivamente para cada posible par de MBRs (R
Pi
, R
Qj
) almacenados en
dichos nodos de ambos R*-trees.
CPCR3 Si se accede a dos nodos hoja (nP y nQ), calcular la distancia de cada posible
par de objetos. Si la distancia es menor o igual que parMasCercano.distancia,
actualizar parMasCercano.distancia y parMasCercano.parObjetos.
El par de objetos ms cercano requerido es el que se corresponde con el valor final de
distancia para parMasCercano.
CPC_Recursivo_Fuerza_Bruta(nP, nQ: R_nodo; parMasCercano: ParObjetos)
01 if nP and nQ son nodos INTERNOS then
02 for every entrada p
i
de nP do
03 for every entrada q
j
de nQ do
04 nP = LeerNodo(p
i
.direccion);
05 nQ = LeerNodo(q
j
.direccion);
06 CPC_Recursivo_Fuerza_Bruta(nP, nQ, parMasCercano);
07 enddo
08 enddo
09 else
10 for every entrada p
i
de nP do
11 for every entrada q
j
de nQ do
12 dist = MinMinDist(p
i
.MBR, q
j
.MBR);
13 if dist parMasCercano.distancia then
14 parMasCercano.distancia = dist;
15 parMasCercano.parObjetos = (p
i
, q
j
);
16 endif
17 enddo
18 enddo
19 endif
Suponiendo que los R*-trees R
P
y R
Q
tienen N y M nodos, respectivamente, el tiempo que
necesita el algoritmo CPC_Recursivo_Fuerza_Bruta para obtener el par ms cercano est
en O(N * M), por tratarse de un esquema en bucle anidado sobre ndices. En dicho algoritmo,
cada entrada de los nodos del R*-tree R
P
se compara con cada entrada de los nodos del ndice
R*-tree R
Q
para encontrar el par de objetos almacenados en las hojas con la menor distancia
entre ellos, realizndose un recorrido recursivo en profundidad sincronizado en los dos ndices
R*-trees.

4.2.4 Algoritmo iterativo sobre dos R*-trees utilizando un
montculo

En este apartado, antes de presentar la aproximacin iterativa para encontrar el par ms
cercano, vamos a estudiar una estructura de datos denominada montculo y todas las
operaciones que tiene asociada, debido a que sta es el ncleo principal para la
implementacin de dicha aproximacin.
Algoritmos para la realizacin de la consulta del par ms cercano utilizando R*-trees
99

4.2.4.1 Montculos

Un montculo (heap) [FSS
+
86, CLR90, BrB97, Seg98] es un tipo especial de rbol binario que
se puede implementar eficientemente en un array sin ningn puntero explcito. Esta estructura
de datos se puede utilizar para representar eficientemente listas dinmicas de prioridad.
Se dice que un rbol binario es esencialmente completo si todo nodo interno, con la posible
excepcin de un nodo especial, tiene exactamente dos hijos. El nodo especial, si existe, est
situado en el nivel 1; y posee un hijo izquierdo pero no tiene hijo derecho. Adems, o bien
todas las hojas se encuentran en el nivel 0, o bien estn en los niveles 0 y 1, y ninguna hoja
del nivel 1 est a la izquierda de un nodo interno del mismo nivel. Intuitivamente, un rbol
esencialmente completo es uno en el que los nodos internos se han subido en el rbol lo
mximo posible, con los nodos del ltimo nivel desplazados hacia la izquierda; las hojas
llenan el ltimo nivel que contiene nodos internos (si queda algn espacio), y despus se
desbordan hacia la izquierda en el nivel 0. La Figura 4.1 ilustra un rbol binario esencialmente
completo que contiene 10 nodos.

A[1]
A[2] A[3]
A[4] A[5]
A[8] A[9] A[10]
A[6] A[7]
Nivel 3
Nivel 2
Nivel 0
Nivel 1

Figura 4.1 rbol binario esencialmente completo.
Si un rbol binario esencialmente completo tiene una altura h, entonces hay un nodo (la
raz) en el nivel h, dos nodos en el nivel h 1, y as sucesivamente; hay 2
h
1 nodos en el
nivel 1, y al menos uno pero no ms de 2
h
en el nivel 0. Si el rbol contiene N nodos en el
total, contando tanto los nodos internos como las hojas, se sigue que 2
h
N 2
h+1
.
Anlogamente, la altura de un rbol que contiene N nodos es h = logN].
Esta clase de rbol se puede representar en un array A poniendo los nodos de profundidad
h, de izquierda a derecha, en las posiciones A[2
h
], A[2
h
+ 1], ..., A[2
h+1
1], con la posible
excepcin del nivel 0, que puede estar incompleto. La Figura 4.1 indica los elementos del
array que corresponden con cada nodo del rbol. Utilizando esta representacin, el padre del
Captulo 4
100
nodo representado en A[i] se encuentra en A[i / 2] para i > 1 (la raz A[1] carece de padre), y
los hijos del nodo representado en A[i] se encuentra en A[2i] y A[2i + 1] siempre que existan.
Definicin. Montculo.
Un montculo es un rbol binario esencialmente completo representado como un array,
donde cada uno de sus nodos incluye un elemento de informacin denominado valor del
nodo.
Propiedad. Propiedad del montculo.
Dado un montculo, el valor de cada nodo interno es mayor o igual que los valores de sus
hijos (montculo mximo). A[i] A[2i] y A[i] A[2i + 1].
En esta estructura de datos, el valor de cada nodo interno es mayor o igual que los valores
de sus hijos, que a su vez tienen valores mayores o iguales que los valores de sus hijos, y as
sucesivamente. La propiedad del montculo asegura que el valor de todo nodo interno es
mayor o igual que los valores de todos los nodos que estn en los subrboles situados por
debajo de l. En particular, el valor de la raz es mayor o igual que los valores de todos los
dems nodos del montculo (montculo mximo).
La Figura 4.2 muestra un ejemplo de montculo con 10 nodos. El rbol subyacente es el
que se muestra en la Figura 4.1, pero ahora hemos marcado cada nodo con su valor. Para
comprobar la propiedad del montculo, el nodo cuyo valor es 9 tienen dos hijos cuyos valores
son 5 y 2 (los dos hijos tienen un valor menor o igual que el valor de su padre).

10
7 9
4 7
2 1 6
5 2

Figura 4.2 Ejemplo de montculo.
Este mismo montculo se puede expresar de manera idntica como un array de la siguiente
forma:
A 10 7 9 4 7 5 2 2 1 6
1 2 3 4 5 6 7 8 9 10
La caracterstica principal de esta estructura de datos es que la propiedad del montculo se
puede restaurar de forma eficiente si se modifica el valor de un nodo. Si el valor de un nodo
Algoritmos para la realizacin de la consulta del par ms cercano utilizando R*-trees
101
crece hasta llegar a ser mayor que el valor de su padre, basta con intercambiar estos dos
valores, y continuar el mismo proceso hacia arriba si es necesario, hasta que se haya
restaurado la propiedad del montculo. Diremos que el valor modificado ha flotado hasta su
nueva posicin dentro del montculo (a esta operacin se le suele denominar Flotar). Si por el
contrario, el valor del nodo decrece de tal manera que pasa a ser menor que el valor de alguno
de sus hijos, entonces basta intercambiar el valor modificado con el mayor de los valores de
los hijos, y continuar este proceso hacia abajo si es necesario, hasta que se restaure la
propiedad del montculo. Diremos que el valor modificado se ha hundido hasta su nueva
posicin dentro del montculo (a esta operacin se le suele denominar Hundir).
El montculo es una estructura ideal para encontrar el mayor de los elementos de un
conjunto (obtenerMaximo), para eliminarlo (eliminarMaximo), para aadir un nuevo nodo
(insertarElemento) o para modificar un nodo existente (modificarElemento). Casi todos estos
procedimientos sobre un montculo se implementan en funcin de las dos operaciones
bsicas: Flotar y Hundir. Los anteriores procedimientos son los que se necesitan para
implementar eficientemente las colas de prioridad dinmicas, donde el elemento con mayor
prioridad est siempre en la raz del montculo (montculo mximo). En [Seg98] se realiza una
implementacin eficiente de todos los procedimientos asociados a un montculo, que
requieren un tiempo en el peor de los casos de O(1) para obtenerMaximo, O(logN) para
eliminarMaximo, O(logN) para insertarElemento, y O(logN) para modificarElemento, sobre
un array de N elementos.
En algunas ocasiones ser preciso utilizar un montculo invertido, tambin denominado
montculo mnimo. Con esto denotamos un rbol binario esencialmente completo en el cual el
valor de todo nodo interno es menor o igual que los valores de sus hijos, y no mayor o igual
como suceda en un montculo mximo. En un montculo mnimo, el elemento ms pequeo
se encuentra en la raz del montculo. Todas las propiedades de un montculo mximo pueden
extenderse fcilmente a un montculo mnimo. A lo largo de todo este trabajo vamos a
representar a esta estructura de datos como se indica en la Figura 4.3 para diferenciarla de un
mtodo de acceso espacial (R*-tree).

Montculo
R*-tree
Mtodo de Acceso Espacial

Figura 4.3 Representacin de un montculo como estructura de datos.
An cuando los montculos pueden utilizarse para implementar de forma eficiente la
mayora de las operaciones necesarias para manejar colas dinmicas de prioridad, hay algunas
operaciones para las que no resultan apropiados. Por ejemplo, no hay una buena manera de
buscar un elemento dado en un montculo. Una buena solucin para esto es implementar una
Captulo 4
102
tabla hash asociada a los elementos que hay almacenados en el montculo en un momento
determinado.

4.2.4.2 Algoritmo iterativo utilizando un montculo

El ncleo para la implementacin de la versin iterativa del algoritmo para encontrar el par
ms cercano es un montculo, donde cada elemento tiene un par de componentes, uno de cada
ndice espacial R*-tree de entrada, R
P
y R
Q
.
Para reducir el tamao global del montculo, no se almacenan pares de elementos en los
que algn componente de dicho par est almacenado en las hojas de cualquier R*-tree. Por
tanto, los pares son siempre de la forma MBR/MBR, cuyos componentes del par son entradas
de los nodos internos de cada R*-tree. Una manera sencilla de estimar el nmero mximo de
pares insertados en el montculo se podra hacer como indicamos a continuacin. Sean R
P
y
R
Q
dos R*-trees de orden (m
P
, M
P
) y (m
Q
, M
Q
), y con alturas h
P
y h
Q
, respectivamente,
entonces el nmero mximo de pares (MBR/MBR) procedentes de nodos internos de R
P
y R
Q

que se insertarn en el montculo es S
P
* S
Q
, donde

1
1
P
h
i
i
P P
M S y

1
1
Q
h
i
i
Q Q
M S
Otra caracterstica del algoritmo es que la combinacin de MBRs procedentes de nodos
internos de R
P
y R
Q
se hace de la forma todos con todos. Es decir, cada entrada del nodo
interno de R
P
se combina con cada entrada del nodo interno de R
Q
, insertndose al final en el
montculo E
P
* E
Q
pares de MBRs, donde E
P
y E
Q
representan el nmero de entradas para
cada nodo interno de R
P
y R
Q
, respectivamente. Al algoritmo correspondiente, donde los dos
R*-trees tienen la misma altura, le denominamos CPC_Monticulo_Fuerza_Bruta, cuya
descripcin por pasos (CPCM#) es la que se indica a continuacin:
CPCM1 Comenzar desde las races de los dos R*-trees, fijar la distancia del par ms
cercano encontrado hasta el momento, parMasCercano.distancia, a infinito ()
y crear el montculo.
CPCM2 Si se accede a un par de nodos internos (nP y nQ), insertar en el montculo
todos los posibles pares de MBRs (R
Pi
, R
Qj
) procedentes de la combinacin de
dichos nodos de ambos R*-trees.
CPCM3 Si se accede a dos nodos hoja (nP y nQ), calcular la distancia de cada posible
par de objetos. Si la distancia es menor o igual que parMasCercano.distancia,
actualizar parMasCercano.distancia y parMasCercano.parObjetos.
CPCM4 Si el montculo est vaco, entonces parar.
CPCM5 Obtener el par de la raz del montculo y repetir el algoritmo desde CPCM2
para este par.
Algoritmos para la realizacin de la consulta del par ms cercano utilizando R*-trees
103
En este algoritmo lo ms importante es establecer la clave de ordenacin del montculo (en
este caso, montculo mnimo). Para esta primera aproximacin utilizaremos informacin
relacionada con el nivel y la altura de los R*-trees. Por ejemplo, sta podra ser clave = (h
P

nivel(R
P
)) + (h
Q
nivel(R
Q
)), donde h
P
, h
Q
, nivel(R
P
) y nivel(R
Q
) son las alturas y niveles
actuales de procesamiento de los R*-trees R
P
y R
Q
, respectivamente. Adems, suponemos que
no se hace ningn tratamiento especial para el caso de que en el montculo existan ms de un
par de MBRs con el mismo valor de clave. Es fcil observar que este algoritmo sigue un
esquema de recorrido en anchura sincronizado en los dos R*-trees, ya que se procesan todos
los pares de un nivel antes de cualquier par del nivel siguiente.
El par de objetos ms cercano requerido es el que se corresponde con el valor final de
distancia para parMasCercano.
CPC_Monticulo_Fuerza_Bruta(RaizP, RaizQ: R_nodo)
01 M = crearMonticulo();
02 parMasCercano.distancia = ;
03 for every entradap p
i
de RaizP do
04 for every entrada q
j
de RaizQ do
05 M.insertarElemento((h
P
p
i
.nivel + h
Q
q
j
.nivel), p
i
.direccion, q
j
.direccion);
06 enddo
07 enddo
08 while (not(M.estaVacio())) do
09 Elem = M.eliminarMinimo();
10 nP = LeerNodo(Elem.direccion_nP);
11 nQ = LeerNodo(Elem.direccion_nQ);
12 if nP and nQ son nodos INTERNOS then
13 for every entrada p
i
de nP do
14 for every entrada q
j
de nQ do
15 M.insertarElemento((h
P
p
i
.nivel + h
Q
q
j
.nivel), p
i
.direccion, q
j
.direccion);
16 enddo
17 enddo
18 else
19 for every entrada p
i
de nP do
20 for every entrada q
j
de nQ do
21 dist = MinMinDist(p
i
.MBR, q
j
.MBR);
22 if dist parMasCercano.distancia then
23 parMasCercano.distancia = dist;
24 parMasCercano.parObjetos = (p
i
, q
j
);
25 endif
26 enddo
27 enddo
28 endif
29 enddo
30 M.destruirMonticulo();
31 return parMasCercano;
Suponiendo que los R*-trees R
P
y R
Q
tienen N y M nodos, respectivamente, el tiempo que
necesita el algoritmo CPC_Monticulo_Fuerza_Bruta para obtener el par ms cercano est
en O(N * M), por tratarse de un recorrido en anchura sincronizado en los dos R*-trees.
Adems de seguir un esquema de recorrido en anchura, CPC_Monticulo_Fuerza_Bruta se
diferencia de CPC_Recursivo_Fuerza_Bruta, en que el primero utiliza una estructura de
datos adicional para evitar la recursividad y las operaciones asociadas a ella requieren tiempo
extra de CPU.
Captulo 4
104

4.3 Algoritmos branch-and-bound para determinar el par
ms cercano. Formas de procesamiento y reglas de poda

La tcnica de branch-and-bound (ramificacin y poda) se utiliza para explorar grafos dirigidos
acclicos, entre los que podemos encontrar a los rboles, con el objetivo de buscar la solucin
ptima de un determinado problema . Esta tcnica consiste en calcular cotas relativas a
soluciones parciales para limitar el nmero de soluciones completas a examinar. En nuestro
caso, como ya sabemos, el problema que nos proponemos resolver es obtener el par ms
cercano de dos conjuntos de objetos almacenados en sendos R*-trees.
Adems, vamos a presentar varias formas de procesamiento en algoritmos branch-and-
bound que determinan el par ms cercano, aplicando mtricas y propiedades entre pares de
MBRs que dan lugar a reglas de poda para este tipo de algoritmos.

4.3.1 Algoritmos branch-and-bound
Branch-and-bound es una tcnica general para el diseo de algoritmos [HoS78, Iba87,
BrB95]. Esta tcnica se puede utilizar para encontrar una solucin ptima a un determinado
problema cuando se recorren estructuras arbreas. Un problema de optimizacin
(minimizacin) generalmente se define de la siguiente manera:
: minimizar f(x)
sujeto a x W
donde W X representa una regin factible del espacio subyacente X. Es decir, W es el
conjunto de soluciones factibles que satisfacen las restricciones impuestas. La funcin f : X
donde el conjunto de los nmeros reales, es denominada funcin objetivo. Una solucin
factible x W es ptima (mnima) si ninguna otra solucin factible y W verifica que f(y) <
f(x).
La idea principal de un algoritmo branch-and-bound es dividir un problema inicial en un
nmero de subproblemas parciales intermedios de tamao ms pequeo. Cada subproblema
est caracterizado por la inclusin de una o ms restricciones que se utilizan para descartar
posibles subproblemas que no conduzcan a la solucin ptima. El proceso de descomposicin
se aplica repetidamente a los subproblemas generados, hasta que cada uno de los
subproblemas no examinados se vuelve a descomponer, se resuelve, o indica que no va a
conducir a la solucin ptima del problema inicial. La tcnica branch-and-bound es
esencialmente una variante o refinamiento de la tcnica backtracking (vuelta atrs) que toma
informacin sobre la optimalidad de soluciones parciales para evitar considerar soluciones
que pueden no ser ptimas, y por tanto reducir el espacio de bsqueda notablemente.
Algoritmos para la realizacin de la consulta del par ms cercano utilizando R*-trees
105
Siguiendo esta tcnica, en cada nodo del rbol calculamos una o ms cotas del posible
valor de aquellas soluciones que pudieran encontrarse ms adelante en el rbol. Si la cota
muestra que cualquiera de estas soluciones es peor que la mejor solucin hallada hasta el
momento, entonces no necesitamos seguir explorando dicha parte del rbol, y sta es podada.
En la versin ms sencilla de los algoritmos branch-and-bound, el clculo de cotas se
combina con un recorrido en profundidad, y sirve para podar ciertas ramas de un rbol que no
nos sern de utilidad para encontrar la solucin ptima. Tambin, las cotas calculadas se
utilizan para seleccionar la primera rama, entre todas las potencialmente posibles, que parece
ms prometedora para explorarla.
La tcnica branch-and-bound tambin utiliza operaciones adicionales para decidir qu
nodo debe explorarse a continuacin y estructuras de datos adicionales para almacenar los
nodos que se han generado y que an no han sido examinados, con el objetivo de que se
exploren segn el orden ptimo y se minimice el nmero de nodos a explorar.
Para los algoritmos branch-and-bound resulta casi imposible dar una idea precisa de lo
bien que se van a comportar ante un problema determinado, empleando una cota dada.
Siempre hay que llegar a un compromiso entre la calidad de la cota calculada y el coste que
supone dicho clculo. Con una cota mejor, examinamos menos nodos, y si tenemos suerte
llegaremos a una solucin ptima ms rpidamente. Por otra parte, puede que empleemos ms
tiempo en cada nodo calculando la cota correspondiente. En el peor caso, puede ocurrir que
incluso una cota excelente no nos permita podar ninguna rama del rbol, desperdicindose
todo el trabajo adicional efectuado en cada nodo para calcular dicha cota. En la prctica, para
problemas del tamao que nos podemos encontrar en aplicaciones reales, es rentable invertir
el tiempo necesario para calcular la mejor cota posible (siempre dentro de lo razonable).
Siguiendo la terminologa propuesta en [RRP96, Iba76, Iba87], para establecer las formas
de procesamiento en nuestros algoritmos branch-and-bound vamos a denotar
0
como el
problema inicial que deseamos resolver (encontrar el par ms cercano de dos conjuntos de
objetos indexados por sendos R*-trees con la misma altura) y f la funcin que deseamos
minimizar (distancia Eucldea entre dos objetos). El proceso de descomposicin de
0
se
representa por un rbol branch-and-bound T = (N, A), donde N es un conjunto de nodos y A es
un conjunto de arcos. La raz de T, denotada por N
0
, se corresponde con el problema inicial

0
dado y los otros nodos del rbol (N
i
) se corresponden con los problemas parciales
i
. El
arco (N
i
, N
j
) A si, y slo si N
j
es generado por N
i
por descomposicin. El conjunto de nodos
terminales u hojas de T, denotado como H, se corresponden con aquellos problemas parciales
que se resuelven sin necesidad de descomposicin. El nivel de N
i
T, que denotamos como
L(N
i
), es la longitud del camino desde N
0
hasta N
i
en T.
Un algoritmo branch-and-bound intenta resolver
0
examinando slo una pequea parte de
N (conjunto de nodos del rbol branch-and-bound T). Esto se lleva a cabo aplicando un
proceso de ramificacin y poda a lo largo de las ramas de T en cuyos nodos N
i
los problemas
parciales
i
no han sido resueltos o no se ha encontrado la solucin ptima (es decir, f(N
i
) >
f(N
0
)). Para cada uno de los problemas parciales o subproblemas (
i
) que se van creando, se
calcula una funcin cota inferior, g, aplicada al nodo de T asociado (g : N ), que ayuda a
eliminar ramas innecesarias. Esta funcin cota representa un lmite inferior de una solucin
ptima (mnima) para un subproblema
i
, es decir g(N
i
) f(N
i
) tal que N
i
N. Los valores de
Captulo 4
106
esta funcin cota inferior deben satisfacer las siguientes condiciones, garantizando su
consistencia:
g(N
i
) f(N
i
), para N
i
N.
g(N
i
) = f(N
i
), para N
i
H.
g(N
j
) g(N
i
), si N
j
es un descendiente de N
i
.
Por otro lado, tambin podemos calcular valores de una funcin cota superior aplicada a
los nodos de T, u : N , para intentar actualizar el valor de la mejor solucin posible que
se puede alcanzar hasta el momento. Si al principio del algoritmo aplicamos esta funcin de
cota superior y nos devuelve valores relativamente pequeos, entonces el proceso de poda del
rbol branch-and-bound ser muy eficaz para la determinacin de la solucin ptima. Al igual
que la funcin cota inferior, los valores de esta funcin cota superior deben satisfacer las
siguientes condiciones, garantizando su consistencia:
u(N
i
) f(N
i
), para N
i
N.
u(N
i
) = f(N
i
), para N
i
H.
Debemos destacar, que no se debe aplicar u(N
i
) a todos los nodos generados por el
algoritmo, pues conforme evoluciona el algoritmo, la actualizacin de la mejor solucin
posible que podemos alcanzar es cada vez menos significativa. Por tanto, esta funcin cota
superior es aplicable a nodos generados al principio del algoritmo.
Un algoritmo branch-and-bound est caracterizado por cuatro procedimientos: Seleccin,
Ramificacin, Poda y Comprobacin de finalizacin. El significado de cada uno de ellos el
siguiente:
Seleccin. En cualquier paso durante la ejecucin de un algoritmo branch-and-bound
existe un conjunto S de subproblemas que han sido generados pero an no se han examinado.
El proceso de seleccin escoge un nico subproblema basado en una funcin de seleccin f
s

aplicada a N, es decir, decide qu nodo ser el siguiente a explorar. Las estrategias de
bsqueda aplicadas al rbol branch-and-bound utilizadas como funciones de seleccin son las
siguientes:
Primero el mejor: f
s
(N) = N
i
, tal que g(N
i
) es el valor de cota ms pequeo en T.
Bsqueda en profundidad: f
s
(N) = N
i
, tal que N
i
es el nodo con mayor profundidad en T.
Bsqueda en anchura: f
s
(N) = N
i
, tal que N
i
es el nodo con menor profundidad en T.
En el procedimiento de seleccin, el recorrido basado en una funcin de seleccin de primero
el mejor y en profundidad se utiliza en la mayora de las situaciones, aunque el recorrido en
anchura debe tenerse en cuenta tambin. La estrategia de bsqueda basada en una funcin de
seleccin de primero el mejor minimiza el nmero de problemas parciales a procesar antes de
su finalizacin. Sin embargo, esto requiere una cantidad de memoria que puede ser una
funcin exponencial del tamao del problema y la mejor cota suele encontrarse en la fase final
del algoritmo [Iba87]. Adems, esta estrategia de bsqueda tiene un inconveniente, ya que en
algunos casos la solucin ptima se alcanza despus de haber procesado casi por completo el
rbol branch-and-bound. Por otro lado, el recorrido en profundidad requiere una cantidad de
memoria que slo es una funcin lineal del tamao del problema [Iba87] y conduce ms
rpidamente a la obtencin de una mejor cota. Sin embargo, si entramos en un subrbol que
no lleva a ninguna solucin ptima, se requieren operaciones adicionales para salir de ese
subrbol, y adems el nmero de subproblemas inspeccionados es normalmente mayor que el
Algoritmos para la realizacin de la consulta del par ms cercano utilizando R*-trees
107
realizado por la funcin de seleccin de primero el mejor [Iba87]. Sin embargo, esta
estrategia de bsqueda da prioridad los nodos del rbol branch-and-bound que tienen una
mayor profundidad, pudindose disponer de soluciones aproximadas (aunque stas no sean las
ptimas) antes de la finalizacin completa del algoritmo. Finalmente, el recorrido en anchura
no es muy recomendable, ya que para llevarlo a cabo requiere de muchos recursos adicionales
y el tiempo de respuesta es bastante superior al de las otras estrategias de bsqueda, aunque
hay situaciones en las que aplicando tcnicas apropiadas de optimizacin global es una
alternativa a tener en cuenta.
Ramificacin. Para un problema especfico se utiliza una determinada regla de
ramificacin que genera nuevos subproblemas ms pequeos de uno establecido en el
procedimiento de seleccin. Despus de generar estos nuevos subproblemas, se calculan los
valores de la funcin cota inferior (g) y opcionalmente los valores de la funcin cota inferior
(u) asociados a ellos.
Poda o Eliminacin. Los nuevos subproblemas creados en el procedimiento de
ramificacin se podan si los valores de cota (g) son estrictamente mayores que la mejor
solucin posible encontrada hasta el momento durante el proceso de bsqueda.
Comprobacin de finalizacin. El algoritmo branch-and-bound termina cuando la lista de
subproblemas est vaca y la mejor solucin posible encontrada hasta el momento es la
solucin ptima del problema original. Adems, se pueden definir algunas reglas auxiliares
que ayuden a identificar soluciones parciales posibles.
A continuacin se muestra el esquema general de un algoritmo branch-and-bound
recursivo sobre el recorrido en profundidad de un ndice R*-tree para encontrar la solucin
ptima (mnimo) en base a un determinado parmetro, distinguiendo un tratamiento diferente
segn el tipo de nodo (interno u hoja) procesado. Si N es el nmero de nodos del R*-tree,
entonces el tiempo de procesamiento en el peor de los casos (no se realiza ninguna poda de las
ramas durante el recorrido en profundidad del rbol) es de orden O(N).
Branch_And_Bound(N: R_nodo; Resultado: objetoOptimo; Cota: Real)
01 if N es un nodo INTERNO then
02 for every entrada n
i
de N do
03 if funcion_metrica(n
i
.elemento) Cota then
04 N = LeerNodo(n
i
.direccion);
05 Branch_And_Bound(N, Resultado, Cota);
06 endif
07 enddo
08 else
09 for every entrada n
i
de N do
10 if funcion_metrica(n
i
.elemento) Cota then
11 Resultado = n
i
;
12 Cota = funcion_metrica(n
i
.elemento);
13 endif
14 enddo
15 endif
Como aclaracin al algoritmo anterior, se puede observar que en las lneas 4 y 5 se lleva a
cabo el proceso de seleccin, donde se escoge el siguiente nodo interno a procesar y se llama
recursivamente al algoritmo para recorrer en profundidad el rbol. Por otro lado, el proceso de
ramificacin se realiza en la lnea 2, donde se generan los nuevos subproblemas a procesar (la
Captulo 4
108
lnea 9 procesa las entradas del nodo hoja (terminal), no dando lugar a ramificacin). En la
lnea 3 se lleva a cabo el proceso de poda, donde los nuevos subproblemas generados en la
fase de ramificacin se descartan segn el valor de una cota (la lnea 10 no considera posibles
soluciones que estn por encima de una cota, que es el menor valor encontrado hasta el
momento de una funcin mtrica aplicada a un elemento del rbol). Por ltimo, la
comprobacin de finalizacin del algoritmo es cuando todas las hojas, que no se han podado,
han sido procesadas haciendo uso de la recursividad para realizar el recorrido en profundidad
del rbol.

4.3.2 Formas de procesamiento en algoritmos branch-and-bound
para encontrar el par ms cercano

Una vez vistos los algoritmos branch-and-bound y sus formas de procesamiento de manera
general, los vamos a aplicar para describir los algoritmos branch-and-bound que van a dar
respuesta a nuestra consulta en cuestin. En nuestro caso: obtener el par ms cercano de
dos conjuntos de objetos almacenados en sendos R*-trees (R
P
y R
Q
); f distancia Eucldea
entre dos objetos espaciales; g mnima distancia Eucldea entre los elementos de dos R*-
trees, u mxima distancia Eucldea entre los elementos de dos R*-trees (y mnima de todas
las mximas distancias Eucldeas entre las caras que forman los elementos de dos R*-trees), y
al principio, el nivel de N
0
es igual a max{altura(R
P
), altura(R
Q
)}.
En primer lugar vamos a estudiar el algoritmo branch-and-bound recursivo basado en un
recorrido en profundidad, que consiste en los tres pasos siguientes:
Primer paso. Empezar a generar el rbol branch-and-bound que se obtiene de la
combinacin de los dos R*-trees de entrada (R
P
y R
Q
). En este caso, el rbol branch-and-
bound va a ser una pila (estructura LIFO) de pares de MBRs cuya clave de ordenacin
depende de la profundidad de los dos R*-trees. Al descomponer el subproblema elegido,
los subproblemas generados a partir de l se vuelven a introducir en la pila. Este mismo
rbol puede generarse utilizando la recursividad que proporcionan la mayora de los
lenguajes de programacin, mediante la expansin de nodos internos, y por ello lo
denominamos algoritmo recursivo.
Segundo paso. Caracterizar cada uno de los cuatro procedimientos representativos de un
algoritmo branch-and-bound.
Seleccin. El par de MBRs con menor MinMinDist(R
Pi
, R
Qj
) es el mejor candidato de
todos los que tienen la misma profundidad.
Ramificacin. El procedimiento de ramificacin consiste en generar una lista de pares
de MBRs procedentes de la expansin y combinacin de dos nodos internos, uno
procedente de R
P
y otro de R
Q
. Cuando ambos nodos son hojas, se resuelven sin
necesidad de ramificacin.
Poda. El procedimiento de eliminacin o poda compara el valor de MinMinDist(R
Pi
,
R
Qj
) de un par de MBRs procedentes de la lista de pares de MBRs generada en el
Algoritmos para la realizacin de la consulta del par ms cercano utilizando R*-trees
109
procedimiento de ramificacin con el valor de distancia del par ms cercano obtenido
hasta el momento, podando todos aquellos pares cuyo valor es estrictamente mayor.
Debido a que no hay ramificacin entre pares procedentes de la combinacin de nodos
hoja, tampoco se aplica ninguna poda sobre ellos. Adems, podemos aplicar un proceso
adicional, previo al anterior, para actualizar la distancia del par ms cercano encontrado
hasta el momento, si es posible, con el mnimo valor de MinMaxDist(R
Pi
, R
Qj
) aplicada
a todos los pares de MBRs procedentes de la lista generada en la fase de ramificacin.
MinMaxDist(R
Pi
, R
Qj
) es una cota superior para la distancia del par ms cercano de los
conjuntos de objetos envueltos por los MBRs R
Pi
y R
Qj
.
Comprobacin de finalizacin. El algoritmo branch-and-bound se detiene cuando se ha
recorrido todo el rbol branch-and-bound o todos los pares de MBRs en todos los
niveles de profundidad tienen un valor de MinMinDist(R
Pi
, R
Qj
) estrictamente mayor
que la distancia del par ms cercano encontrado hasta el momento.
Tercer paso. La solucin ptima a nuestro problema (encontrar el par ms cercano) es el
par global de objetos obtenido del proceso de ramificacin y poda.
La versin iterativa utilizando un montculo del algoritmo branch-and-bound basado en
una funcin de seleccin de primero el mejor consiste tambin en tres pasos que describimos
a continuacin:
Primer paso. Empezar a generar el rbol branch-and-bound que se obtiene de la
combinacin de los dos R*-trees de entrada (R
P
y R
Q
). El rbol branch-and-bound va a ser
un montculo mnimo de pares de MBRs cuya clave de ordenacin es MinMinDist(R
Pi
,
R
Qj
). Es decir, va a ser un montculo en el que el par de MBRs con menor MinMinDist(R
Pi
,
R
Qj
) estar ubicado en la raz, siendo esta mtrica una cota inferior para detectar el par ms
cercano.
Segundo paso. Caracterizar cada uno de los cuatro procedimientos representativos de un
algoritmo branch-and-bound.
Seleccin. El procedimiento de seleccin consiste en escoger el par de MBRs ubicado
en la raz del montculo mnimo, que es el que tiene menor valor de MinMinDist(R
Pi
,
R
Qj
) entre todos los pares de MBRs que forman dicho montculo. Este proceso de
seleccin da lugar a un recorrido basado en una funcin de seleccin de primero el
mejor.
Ramificacin. El procedimiento de ramificacin consiste en generar todos los pares de
MBRs procedentes de la combinacin de dos nodos internos (procedentes de R
P
y R
Q
),
calcular su MinMinDist(R
Pi
, R
Qj
), y prepararlos para su insercin en el montculo
mnimo.
Poda. Cuando se van a insertar los pares de MBRs en el montculo mnimo, despus del
procedimiento de ramificacin, se descartan todos aquellos pares cuya MinMinDist(R
Pi
,
R
Qj
) es estrictamente mayor que el par ms cercano obtenido hasta el momento. En este
procedimiento, tambin se puede aplicar opcionalmente el valor del mnimo de
MinMaxDist(R
Pi
, R
Qj
) calculado entre todos los pares de MBRs procedentes de la
combinacin de dos nodos internos, para actualizar la distancia del par ms cercano
encontrado hasta el momento (reduce el nmero de pares insertados en el montculo
mnimo).
Captulo 4
110
Comprobacin de finalizacin. El algoritmo branch-and-bound se detiene si, y slo si el
montculo est vaco o el par situado en la raz de dicho montculo tiene un valor de
MinMinDist(R
Pi
, R
Qj
) estrictamente mayor que la distancia del par ms cercano
encontrado hasta el momento.
Tercer paso. La solucin ptima a nuestro problema es el par de objetos generado a nivel
global del proceso de ramificacin y poda.
Por ltimo, la versin iterativa del algoritmo branch-and-bound siguiendo en un recorrido
en anchura y combinado con una funcin de seleccin de primero el mejor sobre un conjunto
de montculos organizado por niveles consiste en otros tres pasos:
Primer paso. Empezar a generar el rbol branch-and-bound que se obtiene de la
combinacin de los dos R*-trees de entrada (R
P
y R
Q
). El rbol branch-and-bound va a ser
un conjunto de montculos mnimos organizado por niveles, para los cuales la clave de
ordenacin es MinMinDist(R
Pi
, R
Qj
). Es decir, se va a crear un montculo mnimo por cada
nivel, donde el par de MBRs con menor MinMinDist(R
Pi
, R
Qj
) estar ubicado en la raz, y
hasta que no se procesa completamente un nivel, no se pasa al siguiente.
Segundo paso. Caracterizar cada uno de los cuatro procedimientos representativos de un
algoritmo branch-and-bound.
Seleccin. El procedimiento de seleccin consiste en escoger el par de MBRs ubicado
en la raz (menor valor de MinMinDist(R
Pi
, R
Qj
)) del montculo mnimo no vaco del
nivel ms alto. Este proceso de seleccin da lugar a un recorrido en anchura combinado
con un proceso de seleccin de primero el mejor.
Ramificacin. El procedimiento de ramificacin consiste en generar todos los posibles
pares de MBRs procedentes de la combinacin de dos nodos internos (de los R*-trees
R
P
y R
Q
), calcular su MinMinDist(R
Pi
, R
Qj
), y prepararlos para su insercin en el
montculo mnimo del nivel inmediatamente inferior.
Poda. Cuando se van a insertar los pares de MBRs en el montculo mnimo del nivel
inmediatamente inferior, despus del procedimiento de ramificacin, se descartan todos
aquellos pares cuya MinMinDist(R
Pi
, R
Qj
) es estrictamente mayor que el par ms
cercano obtenido hasta el momento. Tambin podemos aplicar opcionalmente en este
procedimiento la actualizacin de la distancia del par ms cercano obtenido hasta el
momento con el mnimo valor de MinMaxDist(R
Pi
, R
Qj
), si esto es posible.
Comprobacin de finalizacin. El algoritmo branch-and-bound se detiene, si y slo si,
todos los montculos mnimos por niveles estn totalmente vacos o los pares situados
en sus races tienen un valor de MinMinDist(R
Pi
, R
Qj
) estrictamente mayor que la
distancia del par ms cercano encontrado hasta el momento.
Tercer paso. La solucin ptima a nuestro problema es el par de objetos generado a nivel
global del proceso de ramificacin y poda.


Algoritmos para la realizacin de la consulta del par ms cercano utilizando R*-trees
111
4.3.3 Reglas de poda basadas en distancias para los algoritmos
branch-and-bound que determinan el par ms cercano

Las distancias, MinMinDist(R
1
, R
2
) y MinMaxDist(R
1
, R
2
), definidas en el captulo 3 se
utilizan en dos reglas basadas en los teoremas 3.4 y 3.5. Estas reglas se aplican para realizar la
poda en los nodos internos de dos R*-trees cuando se recorren de forma sincronizada desde la
raz hasta las hojas, segn algoritmos branch-and-bound para encontrar el par ms cercano.
Las reglas son las siguientes:
1. Por el teorema 3.4. Si parMasCercano.distancia es la distancia Eucldea del par ms
cercano encontrado hasta el momento, entonces todos los pares de MBRs (R
Pi
, R
Qj
) tal
que R
Pi
R
P
y R
Qj
R
Q
, con distancia MinMinDist(R
Pi
, R
Qj
) estrictamente mayor que
parMasCercano.distancia pueden descartarse, ya que estos pares de MBRs no incluirn
otro par de objetos con distancia menor que parMasCercano.distancia. Esta estrategia
puede utilizarse tanto si el nodo actual es un nodo hoja como si es un nodo interno.
2. Por los teoremas 3.4 y 3.5. Si un par de MBRs (R
Pi
, R
Qj
) tal que R
Pi
R
P
y R
Qj
R
Q

tiene un valor de MinMinDist(R
Pi
, R
Qj
) mayor que MinMaxDist(R
Pi
, R
Qj
) de otro par de
MBRs (R
Pi
, R
Qj
) tal que R
Pi
R
P
y R
Qj
R
Q
, entonces el par (R
Pi
, R
Qj
) puede
descartarse, porque no puede contener al par ms cercano. Adems, si
parMasCercano.distancia es la distancia del par ms cercano encontrado hasta el
momento, entonces podemos actualizarla de la siguiente forma: si MinMaxDist(R
Pi
, R
Qj
)
< parMasCercano.distancia, entonces parMasCercano.distancia = MinMaxDist(R
Pi
,
R
Qj
). Debemos destacar que MinMaxDist(R
Pi
, R
Qj
) slo se utiliza (opcionalmente) como
mtrica para la actualizacin de parMasCercano.distancia entre pares de MBRs cuando
pretendemos encontrar el par ms cercano.
En la Figura 4.4 se pueden observar los posibles pares de MBRs aceptados ((R
P1
, R
Q2
) y
(R
P2
, R
Q2
)) y descartados ((R
P1
, R
Q1
) y (R
P2
, R
Q1
)) aplicando las estrategias de poda basadas
en MinMaxDist(R
Pi
, R
Qj
) para encontrar el par ms cercano. Realmente aplicamos la estrategia
(2) ya que el ejemplo es sobre pares de MBRs y el mnimo valor para MinMaxDist(R
Pi
, R
Qj
)
es MinMaxDist(R
P2
, R
Q2
), descartando todos los pares de MBRs que verifiquen la siguiente
condicin: MinMinDist(R
Pi
, R
Qj
) > MinMaxDist(R
P2
, R
Q2
), y en nuestro ejemplo son (R
P1
,
R
Q1
) y (R
P2
, R
Q1
).
Captulo 4
112

R
P1

R
Q1

mnima MinMaxDist
R
P2
R
Q2

MinMinDist
MinMaxDist

Figura 4.4 Aplicacin de las estrategias de poda para encontrar el par ms cercano.
Es preciso destacar que para realizar la consulta del par ms cercano no utilizamos el
teorema 3.6 (MaxMaxDist) para tratar de reducir parMasCercano.distancia, sino que
utilizamos el teorema 3.5 (MinMaxDist) que lo hace con mayor rapidez.

4.4 Algoritmos branch-and-bound recursivos para
encontrar el par ms cercano

En este apartado vamos a presentar una serie de refinamientos del algoritmo recursivo
CPC_Fuerza_Bruta (recorrido en profundidad) en su versin branch-and-bound, utilizando
para ello las mtricas entre pares de MBRs y reglas de poda vistas anteriormente. Tambin se
presenta una variante en la que se aplica una tcnica muy conocida en geometra
computacional denominada Barrido del Plano [PrS85], para no considerar la combinacin de
todas las entradas de un nodo interno de R
P
con todas las entradas de un nodo interno de R
Q
,
reduciendo considerablemente el coste de CPU.

4.4.1 Algoritmo branch-and-bound recursivo MINMINDIST

Una mejora del algoritmo CPC_Recursivo_Fuerza_Bruta para la consulta del par ms
cercano consiste en hacer uso del teorema 3.4 (regla de poda 1) y podar las ramas de ambos
R*-trees que no nos conducen a la solucin ptima. Esto quiere decir, propagar el algoritmo
hacia abajo slo para aquellos pares de MBRs (R
Pi
, R
Qj
) procedentes de la combinacin de
dos nodos internos de ambos R*-trees (con la misma altura) verificando que su mnima
distancia es menor o igual que la distancia del par ms cercano de objetos encontrado hasta el
momento, MinMinDist(R
Pi
, R
Qj
) parMasCercano.distancia. Al algoritmo le vamos a
Algoritmos para la realizacin de la consulta del par ms cercano utilizando R*-trees
113
denominar CPC_Recursivo_MINMINDIST y el paso CPCR2 del algoritmo
CPC_Fuerza_Bruta ahora debera ser:
CPCR2 Si se accede a un par de nodos internos (nP y nQ), calcular MinMinDist(R
Pi
,
R
Qj
) para cada posible par de MBRs (R
Pi
, R
Qj
) y propagar recursivamente hacia
abajo en los dos R*-trees slo para aquellos pares de MBRs (R
Pi
, R
Qj
) que
verifiquen MinMinDist(R
Pi
, R
Qj
) parMasCercano.distancia.
El par de objetos ms cercano requerido es el que se corresponde con el valor final de la
distancia para parMasCercano.
CPC_Recursivo_MINMINDIST(nP, nQ: R_nodo; parMasCercano: ParObjetos)
01 if nP and nQ son nodos INTERNOS then
02 for every entrada p
i
de nP do
03 for every entrada q
j
de nQ do
04 if MinMinDist(p
i
.MBR, q
j
.MBR) parMasCercano.distancia then
05 nP = LeerNodo(p
i
.direccion);
06 nQ = LeerNodo(q
j
.direccion);
07 CPC_Recursivo_MINMINDIST(nP, nQ, parMasCercano);
08 endif
09 enddo
10 enddo
11 else
12 for every entrada p
i
de nP do
13 for every entrada q
j
de nQ do
14 dist = MinMinDist(p
i
.MBR, q
j
.MBR);
15 if dist parMasCercano.distancia then
16 parMasCercano.distancia = dist;
17 parMasCercano.parObjetos = (p
i
, q
j
);
18 endif
19 enddo
20 enddo
21 endif

4.4.2 Algoritmo branch-and-bound recursivo
MINMAXDIST_MINMINDIST

Una mejora del algoritmo CPC_Recursivo_MINMINDIST para la consulta del par ms
cercano consiste en intentar minimizar el valor de parMasCercano.distancia (distancia del par
ms cercano encontrado hasta el momento). Esto puede hacerse utilizando el teorema 3.5
(regla de poda 2). Es decir, cuando se visite un par de nodos internos recorriendo
recursivamente hacia abajo los dos R*-trees y realizando todas las posibles combinaciones de
MBRs (R
Pi
, R
Qj
), comprobamos si MinMaxDist(R
Pi
, R
Qj
) aplicada a cada par de MBRs puede
producir un valor de parMasCercano.distancia ms pequeo. Debido a que el teorema 3.5 se
verifica para al menos un par de objetos incluidos en ambos MBRs, esta mejora la utilizamos
para optimizar la consulta del par ms cercano. Al algoritmo le vamos a denominar
CPC_Recursivo_MINMAXDIST_MINMINDIST y el paso CPCR2 respecto del algoritmo
CPC_Recursivo_MINMINDIST ahora debera ser:
Captulo 4
114
CPCR2 Si se accede a un par de nodos internos (nP y nQ), calcular el mnimo
MinMaxDist(R
Pi
, R
Qj
) para cada posible par de MBRs (R
Pi
, R
Qj
), y si es menor
que parMasCercano.distancia, actualizar parMasCercano.distancia. Calcular
MinMinDist(R
Pi
, R
Qj
) y propagar recursivamente hacia abajo en los dos R*-
trees slo para aquellos pares de MBRs (R
Pi
, R
Qj
) que verifiquen
MinMinDist(R
Pi
, R
Qj
) parMasCercano.distancia.
El par ms cercano requerido es el que se corresponde con el valor final de la distancia
para parMasCercano.
CPC_Recursivo_MINMAXDIST_MINMINDIST(nP, nQ: R_nodo; parMasCercano: ParObjetos)
01 if nP and nQ son nodos INTERNOS then
02 for every entrada p
i
de nP do
03 for every entrada q
j
de nQ do
04 if MinMaxDist(p
i
.MBR, q
j
.MBR) < parMasCercano.distancia then
05 parMasCercano.distancia = MinMaxDist(p
i
.MBR, q
j
.MBR);
06 endif
07 enddo
08 enddo
09 for every entrada p
i
de nP do
10 for every entrada q
j
de nQ do
11 if MinMinDist(p
i
.MBR, q
j
.MBR) parMasCercano.distancia then
12 nP = LeerNodo(p
i
.direccion);
13 nQ = LeerNodo(q
i
.direccion);
14 CPC_Recursivo_MINMAXDIST_MINMINDIST(nP, nQ, parMasCercano);
15 endif
16 enddo
17 enddo
18 else
19 for every entrada p
i
de nP do
20 for every entrada q
j
de nQ do
21 dist = MinMinDist(p
i
.MBR, q
j
.MBR);
22 if dist parMasCercano.distancia then
23 parMasCercano.distancia = dist;
24 parMasCercano.parObjetos = (p
i
, q
j
);
25 endif
26 enddo
27 enddo
28 endif
Para ilustrar como se aplican los teoremas 3.4 y 3.5 (reglas de poda 1 y 2) para tratar de
actualizar el valor de parMasCercano.distancia y propagar la recursividad en los dos R*-trees,
mostramos la siguiente grfica (Figura 4.5) a ttulo de ejemplo.
Algoritmos para la realizacin de la consulta del par ms cercano utilizando R*-trees
115

R
P1

R
Q1

mnima MinMaxDist
R
P2

R
Q2

MinMinDist
MinMaxDist

Figura 4.5 Distancias entre dos MBRs para el algoritmo
CPC_Recursivo_MINMAXDIST_MINMINDIST.
En la Figura 4.5 se representan dos nodos de dos R*-trees (rectngulos minimales en lneas
discontinuas) que contienen dos MBRs (rectngulos minimales en lnea continua) y las
distancias MinMaxDist(R
Pi
, R
Qj
) y MinMinDist(R
Pi
, R
Qj
) entre cada par de MBRs. La mnima
MinMaxDist(R
Pi
, R
Qj
) es la del par (R
P1
, R
Q2
). Supongamos que este valor es menor que
parMasCercano.distancia, por tanto parMasCercano.distancia se actualiza con
MinMaxDist(R
P1
, R
Q2
). Es evidente que MinMinDist(R
P2
, R
Q1
) > MinMinDist(R
P1
, R
Q1
) >
parMasCercano.distancia. Esto significa que las ramas correspondientes a los pares de MBRs
(R
P2
, R
Q1
) y (R
P1
, R
Q1
) se podarn.

4.4.3 Algoritmo branch-and-bound recursivo
MINMAXDIST_MINMINDIST Ordenado

Una mejora del algoritmo CPC_Recursivo_MINMAXDIST_MINMINDIST para la
consulta del par ms cercano est basada en la idea de que los pares de MBRs que tienen
menor MinMinDist(R
Pi
, R
Qj
), tienen mayor probabilidad de contener el par ms cercano,
dando lugar a un menor valor para parMasCercano.distancia (distancia del par de objetos ms
cercano encontrado hasta el momento) ms rpidamente conforme se procesan dichos pares,
generando as el par ms cercano con mayor rapidez. Dicha mejora se produce cuando se
accede a dos nodos internos. Se ordenan los pares de MBRs (R
Pi
, R
Qj
) generados de la
combinacin de MBRs de ambos nodos en orden ascendente de MinMinDist(R
Pi
, R
Qj
), y se
propaga hacia abajo recursivamente el algoritmo sobre los dos R*-trees segn dicho orden. Es
claro que siguiendo este orden de procesamiento se mejora la poda de ramas en ambos R*-
trees que con toda seguridad no nos van a conducir a la solucin ptima. Al algoritmo le
vamos a denominar CPC_Recursivo_MINMAXDIST_MINMINDIST_Ordenado y el paso
CPCR2 respecto del algoritmo CPC_Recursivo_MINMAXDIST_MINMINDIST ahora
debera ser:
CPCR2 Si se accede a un par de nodos internos (nP y nQ), calcular el mnimo
MinMaxDist(R
Pi
, R
Qj
) para cada posible par de MBRs (R
Pi
, R
Qj
), y si es menor
Captulo 4
116
que parMasCercano.distancia, actualizar parMasCercano.distancia. Calcular
MinMinDist(R
Pi
, R
Qj
) y ordenar todos los posibles pares de MBRs (R
Pi
, R
Qj
) en
orden ascendente de MinMinDist(R
Pi
, R
Qj
). Siguiendo este orden, propagar
recursivamente hacia abajo en los dos R*-trees slo para aquellos pares de
MBRs (R
Pi
, R
Qj
) que verifiquen MinMinDist(R
Pi
, R
Qj
)
parMasCercano.distancia.
El par de objetos ms cercano requerido es el que se corresponde con el valor final de la
distancia para parMasCercano.
CPC_Recursivo_MINMAXDIST_MINMINDIST_Ordenado(nP, nQ: R_nodo; parMasCercano: ParObjetos)
01 if nP and nQ son nodos INTERNOS then
02 Total = nP.numeroDeEntradas * nQ.numeroDeEntradas;
03 Crear_Lista(LISTAMINMINDIST, Total);
04 for every entrada p
i
de nP do
05 for every entrada q
j
de nQ do
06 t = (i * nQ.numeroDeEntradas) + j;
07 LISTAMINMINDIST[t].MinMinDist = MinMinDist(p
i
.MBR, q
j
.MBR);
08 LISTAMINMINDIST[t].direccion_nP = p
i
.direccion;
09 LISTAMINMINDIST[t].direccion_nQ = q
j
.direccion;
10 if MinMaxDist(p
i
.MBR, q
j
.MBR) < parMasCercano.distancia then
11 parMasCercano.distancia = MinMaxDist(p
i
.MBR, q
j
.MBR);
12 endif
13 enddo
14 enddo
15 Ordenar_Lista(LISTAMINMINDIST, 0, (Total 1));
16 t = 0;
17 while ((LISTAMINMINDIST[t].MinMinDist parMasCercano.distancia) and (t < Total)) do
18 nP = LeerNodo(LISTAMINMINDIST[t].direccion_nP);
19 nQ = LeerNodo(LISTAMINMINDIST[t].direccion_nQ);
20 CPC_Recursivo_MINMAXDIST_MINMINDIST_Ordenado(nP, nQ, parMasCercano);
21 t = t +1;
22 enddo
23 Destruir_Lista(LISTAMINMINDIST);
24 else
25 for every entrada p
i
de nP do
26 for every entrada q
j
de nQ do
27 dist = MinMinDist(p
i
.MBR, q
j
.MBR);
28 if dist parMasCercano.distancia then
29 parMasCercano.distancia = dist;
30 parMasCercano.parObjetos = (p
i
, q
j
);
31 endif
32 enddo
33 enddo
34 endif
En la Figura 4.5, el orden de pares de MBRs que seguira el algoritmo en base a
MinMinDist(R
Pi
, R
Qj
) es: (R
P1
, R
Q2
), (R
P2
, R
Q2
), (R
P1
, R
Q1
) y (R
P2
, R
Q1
), pero los nicos pares
que procesaramos seran (R
P1
, R
Q2
) y (R
P2
, R
Q2
), ya que su valor de MinMinDist(R
Pi
, R
Qj
) es
menor que el mnimo de MinMaxDist(R
Pi
, R
Qj
) determinado por (R
P1
, R
Q2
).
Debido a que los diferentes algoritmos de ordenacin suelen dar en general un orden
diferente, cuando un mismo valor aparece varias veces, la eleccin de un algoritmo de
ordenacin afecta al comportamiento del algoritmo que encuentra el par ms cercano. Se han
Algoritmos para la realizacin de la consulta del par ms cercano utilizando R*-trees
117
probado casi todos los algoritmos de ordenacin conocidos (QuickSort, MergeSort, HeapSort,
Insercin, Seleccin, Burbuja, etc.) sobre LISTAMINMINDIST, y el que ha proporcionado
en todos los casos una mejor ordenacin de pares de MBRs es MergeSort (su costo de CPU
para una lista de N elementos, est en O(N * logN) [Seg98]), por lo que ha sido el elegido
para realizar la ordenacin de todos posibles pares de MBRs procedentes de la combinacin
de dos nodos internos de sendos R*-trees segn su MinMinDist(R
Pi
, R
Qj
).
En este algoritmo pueden aparecer pares de MBRs con el mismo valor de MinMinDist(R
Pi
,
R
Qj
) en la lista LISTAMINMINDIST, sobre todo cuando hay un elevado grado de solape entre
los MBRs almacenados en nodos internos (muchos pares con MinMinDist(R
Pi
, R
Qj
) = 0). Por
esta razn, pueden existir varios criterios para tratar de mejorar el rendimiento del algoritmo,
reorganizando dicha lista a nivel local para todos aquellos pares de MBRs con un mismo valor
de MinMinDist(R
Pi
, R
Qj
). A continuacin presentamos ocho criterios para el tratamiento de
dichos empates, manteniendo el mismo orden de elementos en LISTAMINMINDIST segn
MinMinDist(R
Pi
, R
Qj
) generado de aplicar un mtodo de ordenacin determinado. As, en caso
de que dos o ms pares de MBRs tengan el mismo valor de MinMinDist(R
Pi
, R
Qj
), podemos
elegir el par que tenga:
1. El menor nivel de los componentes de cada par. En caso de empate, segn el MBR ms
pequeo en funcin de su rea.
2. El mayor nivel de los MBRs que forman el par. En caso de empate, segn el MBR ms
grande en funcin de su rea. El rea de un MBR se expresa como un porcentaje del
rea de la raz de su R*-tree.
3. El menor valor de MinMaxDist(R
Pi
, R
Qj
) entre los MBRs que forman el par.
4. La mayor suma de reas de sus MBRs.
5. La menor diferencia de reas entre el MBR que engloba a los dos MBRs que forman
cada uno de los pares.
6. La mayor rea de solape entre los elementos de cada par.
7. El mayor nivel de profundidad de los MBRs que forman el par. Poltica de tratamiento
de empates considerada en [HjS98] y que es un caso particular de la primera.
8. El menor nivel de profundidad de los componentes de cada par. Poltica de tratamiento
de empates considerada en [HjS98] y que es un caso particular de la segunda.
Una mejora sobre CPC_Recursivo_MINMAXDIST_MINMINDIST_Ordenado es
gestionar LISTAMINMINDIST como un montculo mnimo utilizando como clave de
ordenacin MinMinDist(R
Pi
, R
Qj
), donde el tiempo empleado para insertar un elemento y
eliminar el mnimo est en O(logN) [Seg98]. Adems, organizando LISTAMINMINDIST
como un montculo mnimo evitamos realizar la operacin de ordenacin (coste de al menos
O(N * logN)) en la lnea 15, lo que significa un ahorro de tiempo cuando N es grande (N =
nP.numeroDeEntradas * nQ.numeroDeEntradas). N es un valor que depender del orden de
los R*-trees. Tambin debemos indicar que los diferentes criterios para el tratamiento de
pares con el mismo valor de MinMinDist(R
Pi
, R
Qj
) expuestos anteriormente son perfectamente
Captulo 4
118
aplicables sobre LISTAMINMINDIST organizada como un montculo mnimo. Al algoritmo
le vamos a denominar CPC_Recursivo_MINMAXDIST_MINMINDIST_Ordenado_M y
se presenta a continuacin:
CPC_Recursivo_MINMAXDIST_MINMINDIST_Ordenado_M(nP, nQ: R_nodo; parMasCercano:
ParObjetos)
01 if nP and nQ son nodos INTERNOS then
02 LISTAMINMINDIST = crearMonticulo(nP.numeroDeEntradas * nQ.numeroDeEntradas);
03 for every entrada p
i
de nP do
04 for every entrada q
j
de nQ do
05 LISTAMINMINDIST.insertarElemento(MinMinDist(p
i
.MBR, q
j
.MBR),
p
i
.direccion, q
j
.direccion);
06 if MinMaxDist(p
i
.MBR, q
j
.MBR) < parMasCercano.distancia then
07 parMasCercano.distancia = MinMaxDist(p
i
.MBR, q
j
.MBR);
08 endif
09 enddo
10 enddo
11 while ((LISTAMINMINDIST.obtenerMinimo().distancia parMasCercano.distancia) and
(not(LISTAMINMINDIST.estaVacio()))) do
12 Elem = LISTAMINMINDIST.eliminarMinimo();
13 nP = LeerNodo(Elem.direccion_nP);
14 nQ = LeerNodo(Elem.direccion_nQ);
15 CPC_Recursivo_MINMAXDIST_MINMINDIST_Ordenado_M(nP, nQ, parMasCercano);
16 enddo
17 LISTAMINMINDIST.destruirMonticulo();
18 else
19 for every entrada p
i
de nP do
20 for every entrada q
j
de nQ do
21 dist = MinMinDist(p
i
.MBR, q
j
.MBR);
22 if dist parMasCercano.distancia then
23 parMasCercano.distancia = dist;
24 parMasCercano.parObjetos = (p
i
, q
j
);
25 endif
26 enddo
27 enddo
28 endif

4.4.4 Algoritmo branch-and-bound recursivo utilizando la tcnica
de Barrido del Plano

Otra aproximacin para mejorar la consulta del par ms cercano consiste en ordenar los
MBRs de los nodos de ambos R*-trees de acuerdo con sus valores de coordenadas segn una
dimensin y despus barrer el plano de izquierda a derecha sobre uno de los ejes
(dimensiones). A esta tcnica se le conoce con el nombre de Barrido del Plano (plane-sweep)
[PrS85] y se suele utilizar para el clculo de intersecciones entre objetos, como ocurre en el
join espacial con el predicado solapa presentado en [BKS93a], reduciendo el tiempo de
respuesta. Esta tcnica, con pequeas modificaciones, la utilizaremos para obtener el par ms
cercano.
Algoritmos para la realizacin de la consulta del par ms cercano utilizando R*-trees
119
Durante el Barrido del Plano, escogemos un MBR pivote de uno de los nodos y lo
emparejamos con cada MBR del otro nodo verificando que MinMinDist(R
Pi
, R
Qj
)
parMasCercano.distancia. Se genera entonces una ventana deslizante con longitud igual a
parMasCercano.distancia ms la longitud del MBR pivote actual en la dimensin de barrido.
Por ejemplo, en la Figura 4.6 podemos observar que el MBR R
P1
de un nodo de R
P
se escoge
como pivote y se empareja con los MBRs R
Q1
, R
Q2
, R
Q3
y R
Q4
de un nodo de R
Q
, que son los
que tienen una distancia menor o igual que parMasCercano.distancia a lo largo del eje de
barrido (en este caso, el eje X).

R
Q7

R
Q4

R
Q1

Eje de Barrido
R
Q3

R
Q5

R
Q6

R
P1

R
P2

R
P4

R
P5

R
P6

R
P3

R
Q2

parMasCercano.distancia
Ventana Deslizante

Figura 4.6 Procesamiento de pares de MBRs con la tcnica de Barrido del Plano.
Como se demuestra en [SML00], la distancia sobre el eje (dimensin) de barrido de
cualquier par de MBRs, MinMinDist(R
Pi
, R
Qj
, ejeBarrido) es siempre menor o igual que la
distancia real entre ellos, MinMinDist(R
Pi
, R
Qj
). Es decir, MinMinDist(R
Pi
, R
Qj
, ejeBarrido)
MinMinDist(R
Pi
, R
Qj
). Todos los MBRs que tengan MinMinDist(pivote, MBR, ejeBarrido) >
parMasCercano.distancia pueden descartarse respeto a dicho pivote, ya que no contendrn
nunca el par ms cercano. Adems, el clculo de la distancia sobre el eje de barrido para un
par de MBRs es menos costoso que el clculo de MinMinDist(R
Pi
, R
Qj
), ya que, entre otras
cosas, se evita realizar el clculo de una raz cuadrada y la influencia de otras dimensiones en
el clculo de la distancia. Por todo esto, MinMinDist(R
Pi
, R
Qj
) se calcula slo para pares de
MBRs (uno de ellos es el MBR pivote) cuya distancia sobre el eje de barrido es menor o igual
que parMasCercano.distancia. Esta mejora nos permite realizar un nmero menor de clculos
de distancias entre pares de MBRs (MinMinDist(R
Pi
, R
Qj
)), dando lugar a un ahorro
considerable en el tiempo de respuesta de la consulta.
Como hemos comentado anteriormente, esta tcnica consiste en una ordenacin y un
barrido del plano. Para realizar dicha ordenacin de los MBRs en el espacio sin perder la
propiedad de localidad, debemos escoger un eje y una direccin de barrido [SML00].
En primer lugar se establece un eje (dimensin) de barrido, ya que cuanto ms dispersos
estn los MBRs en el espacio a lo largo de una dimensin, menor es la probabilidad de que la
distancia sobre el eje de barrido de un par de MBRs sea menor o igual que
parMasCercano.distancia y, por tanto, el nmero de pares de ramas que se podarn en ambos
R*-trees ser mayor. O equivalentemente, si en una dimensin los MBRs estn muy
Captulo 4
120
concentrados, entonces mayor es la probabilidad de que la distancia sobre el eje de barrido
entre pares de MBRs sea menor o igual que parMasCercano.distancia, y sern muchos los
pares de ramas que se explorarn y muy pocos los que se podarn. En [SML00] se introduce
una mtrica denominada ndice de barrido, que es una estimacin normalizada del nmero de
pares de MBRs para los que es necesario calcular su distancia, escogindose como eje de
barrido a la dimensin con el menor ndice de barrido. En la Figura 4.7 se muestran dos nodos
con MBRs. Para este caso la mejor seleccin del eje de barrido es el eje Y, ya que los MBRs
estn ms dispersos en esa dimensin. Por otro lado, si escogemos la dimensin X como eje
de barrido ningn par de ramas se podar, ya que la distancia sobre dicho eje entre todos los
pares MBRs es menor o igual que parMasCercano.distancia.

Y
X
parMasCercano.distancia
p
a
r
M
a
s
C
e
r
c
a
n
o
.
d
i
s
t
a
n
c
i
a


Figura 4.7 Efecto de la seleccin de un eje de barrido.
Una vez establecido el eje de barrido, debemos fijar una direccin de barrido para ordenar
(ascendente o descendentemente) los MBRs de un nodo segn su menor valor del intervalo en
dicho eje. En [SML00] la direccin de barrido se determina comparando la longitud relativa
de los intervalos izquierdo y derecho proyectados sobre el eje de barrido. Es decir, si la
longitud del intervalo izquierdo proyectado sobre el eje de barrido es ms pequea que la
longitud del intervalo derecho, entonces la direccin de barrido determinar una ordenacin
ascendente; si ocurre el caso contrario (longitud del intervalo derecho es menor que la
longitud del intervalo izquierdo) la direccin de barrido dar lugar a una ordenacin
descendente.
En la Figura 4.8 se consideran los tipos de pares de MBRs (R
Pi
, R
Qj
) proyectados sobre el
eje de barrido (X). La proyeccin de MBRs sobre el eje de barrido genera tres intervalos
cerrados, a menos que los MBRs estn completamente solapados. En la Figura 4.8.a, podemos
contemplar el caso en que la proyeccin del par de MBRs sobre el eje de barrido se solapan,
un intervalo en la izquierda es generado por R
Pi
, uno en la mitad por R
Pi
y R
Qj
, y otro a la
derecha por R
Qj
. En la Figura 4.8.b, se puede observar el caso de ausencia del intervalo mitad
puesto que los dos intervalos de proyeccin de ambos MBRs son disjuntos. Otro caso se
presenta en la Figura 4.8.c, donde ambos intervalos, el de la izquierda y el de la derecha
pueden proyectarse desde el mismo MBR, cuando un MBR est contenido en el otro.
Algoritmos para la realizacin de la consulta del par ms cercano utilizando R*-trees
121

R
Qj

Eje de Barrido
R
Pi

R
Qj

R
Pi

R
Qj

R
Pi

(a) (b) (c)

Figura 4.8 Tres tipos de pares de MBRs proyectados sobre el eje de barrido.
Es decir, con la seleccin de un eje de barrido hacemos que la poda de pares de ramas cuya
distancia entre pares de MBRs es mayor que parMasCercano.distancia sea ms efectiva,
mientras que con la seleccin de una direccin de barrido hacemos que el valor de
parMasCercano.distancia se reduzca con mayor rapidez.
Una vez establecidos los criterios de ordenacin debemos explicar el proceso de barrido
del plano. Para ello, primero ordenamos segn dichos criterios los nodos nP ynQ de los R*-
trees R
P
y R
Q
, respectivamente. Por tanto, de esta ordenacin obtenemos que R
Pi
.min
R
Pi+1
.min : 0i<|nP| y R
Qj
.min R
Qj+1
.min : 0j<|nQ|, donde min representa el menor valor
del intervalo asociado al MBR segn el eje de barrido, y |nP| y |nQ| el nmero de entradas de
nP y nQ, respectivamente. Despus, cogemos un MBR pivote que no ha sido procesado hasta
el momento de nP o de nQ dependiendo si R
Pi
.min < R
Qj
.min o R
Pi
.min R
Qj
.min. A
continuacin, dicho MBR pivote, lo emparejamos con los restantes MBRs no marcados del
otro nodo ordenado. Por ejemplo, si el pivote es R
Pi
, lo emparejamos con todos los MBRs de
nQ (R
Qj
) no marcados hasta el momento. Una vez obtenido un par de MBRs candidatos, para
que estos puedan procesarse debern cumplir dos condiciones: la primera de ellas es que
todos los pares de MBRs que tienen una MinMinDist(R
Pi
, R
Qj
, ejeBarrido) >
parMasCercano.distancia son descartados respecto del MBR pivote, la segunda condicin
escoge como pares de MBRs para ser procesados en la bsqueda del par ms cercano los que
tengan MinMinDist(R
Pi
, R
Qj
) parMasCercano.distancia (donde R
Pi
o R
Qj
ser el MBR
pivote). Por ltimo, el MBR pivote se marca para que no se considere en futuros
emparejamientos. Al algoritmo le vamos a denominar CPC_Recursivo_Barrido_Plano y el
paso CPCR2 respecto del algoritmo CPC_Recursivo_MINMINDIST ahora debera ser:
CPCR2 Si se accede a un par de nodos internos (nP y nQ), ordenar ambos nodos segn
los criterios del eje y direccin de barrido [SML00]. Escoger un MBR pivote
que no haya sido procesado hasta el momento de nP o nQ, y emparejarlo con
los restantes MBRs no marcados del otro nodo. Propagar recursivamente hacia
abajo en los dos R*-trees slo para aquellos pares de MBRs (R
Pi
, R
Qj
) que
verifiquen MinMinDist(R
Pi
, R
Qj
, ejeBarrido) parMasCercano.distancia y
MinMinDist(R
Pi
, R
Qj
) parMasCercano.distancia (donde R
Pi
o R
Qj
ser el
MBR pivote). Una vez emparejado el MBR pivote con todos los MBRs del otro
nodo, se marca como procesado y continuamos hasta que todos los MBRs de
nP nQ hayan sido considerados.
El par de objetos ms cercano requerido es el que se corresponde con el valor final de la
distancia para parMasCercano.
Captulo 4
122
CPC_Recursivo_Barrido_Plano(nP, nQ: R_nodo; parMasCercano: ParObjetos)
01 if nP and nQ son nodos INTERNOS then
02 Ordenar_Nodo(nP, ejeBarrido, direccionBarrido);
03 Ordenar_Nodo(nQ, ejeBarrido, direccionBarrido);
04 i = 0;
05 j = 0;
06 while ((i < nP.numeroDeEntradas) and (j < nQ.numeroDeEntradas)) do
07 if (nP.p
i
.MBR.min[ejeBarrido] < nQ.q
j
.MBR.min[ejeBarrido]) then
08 k = j;
09 while (k < nQ.numeroDeEntradas) do
10 if MinMinDist(nP.p
i
.MBR, nQ.q
k
.MBR, ejeBarrido) parMasCercano.distancia then
11 if MinMinDist(nP.p
i
.MBR, nQ.q
k
.MBR) parMasCercano.distancia then
12 nP = LeerNodo(nP.p
i
.direccion);
13 nQ = LeerNodo(nQ.q
k
.direccion);
14 CPC_Recursivo_Barrido_Plano(nP, nQ, parMasCercano);
15 endif
16 else
17 break;
18 endif
19 k = k + 1;
20 enddo
21 i = i + 1;
22 else
23 k = i;
24 while (k < nP.numeroDeEntradas) do
25 if MinMinDist(nP.p
k
.MBR, nQ.q
j
.MBR, ejeBarrido) parMasCercano.distancia then
26 if MinMinDist(nP.p
k
.MBR, nQ.q
j
.MBR) parMasCercano.distancia then
27 nP = LeerNodo(nP.p
k
.direccion);
28 nQ = LeerNodo(nQ.q
j
.direccion);
29 CPC_Recursivo_Barrido_Plano(nP, nQ, parMasCercano);
30 endif
31 else
32 break;
33 endif
34 k = k + 1;
35 enddo
36 j = j + 1;
37 endif
38 enddo
39 else
40 for every entrada p
i
de nP do
41 for every entrada q
j
de nQ do
42 dist = MinMinDist(p
i
.MBR, q
j
.MBR);
43 if dist parMasCercano.distancia then
44 parMasCercano.distancia = dist;
45 parMasCercano.parObjetos = (p
i
, q
j
);
46 endif
47 enddo
48 enddo
49 endif
En el algoritmo CPC_Recursivo_Barrido_Plano a nivel de hojas (lneas 40-48), en lugar
de combinar todas las entradas de un nodo hoja del R*-tree R
P
(nP) con todas las entradas de
un nodo hoja del R*-tree R
Q
(nQ), se puede aplicar tambin la tcnica de Barrido del Plano,
quedando el algoritmo de la siguiente forma cuando se combinan dos nodos hoja (a partir de
la lnea 40):
Algoritmos para la realizacin de la consulta del par ms cercano utilizando R*-trees
123
40 Ordenar_Nodo(nP, ejeBarrido, direccionBarrido);
41 Ordenar_Nodo(nQ, ejeBarrido, direccionBarrido);
42 i = 0;
43 j = 0;
44 while ((i < nP.numeroDeEntradas) and (j < nQ.numeroDeEntradas)) do
45 if (nP.p
i
.MBR.min[ejeBarrido] < nQ.q
j
.MBR.min[ejeBarrido]) then
46 k = j;
47 while (k < nQ.numeroDeEntradas) do
48 if MinMinDist(p
i
, q
k
, ejeBarrido) parMasCercano.distancia then
49 dis t = MinMinDist(p
i
.MBR, q
k
.MBR);
50 if dist parMasCercano.distancia then
51 parMasCercano.distancia = dist;
52 parMasCercano.parObjetos = (p
i
, q
k
);
53 endif
54 else
55 break;
56 endif
57 k = k + 1;
58 enddo
59 i = i + 1;
60 else
61 k = i;
62 while (k < nP.numeroDeEntradas) do
63 if MinMinDist(p
k
, q
j
, ejeBarrido) parMasCercano.distancia then
64 dist = MinMinDist(p
k
.MBR, q
j
.MBR);
65 if dist parMasCercano.distancia then
66 parMasCercano.distancia = dist;
67 parMasCercano.parObjetos = (p
k
, q
j
);
68 endif
69 else
70 break;
71 endif
72 k = k + 1;
73 enddo
74 j = j + 1;
75 endif
76 enddo
77 endif
El algoritmo para un par de nodos (nP y nQ) puede ejecutarse en un tiempo que est en
O(|nP| + |nQ| + ), donde |nP| y |nQ| son el nmero de MBRs que intervienen en el
emparejamiento para el nodo de R
P
y R
Q
, respectivamente, y es el nmero de pares de
MBRs cuya MinMinDist(R
Pi
, R
Qj
, ejeBarrido) es menor o igual que parMasCercano.distancia
(donde R
Pi
o R
Qj
puede ser el MBR pivote). La complejidad de aplicar la tcnica de Barrido
del Plano para esta variante de nuestro algoritmo, justifica el coste adicional de la ordenacin
de ambos nodos (nP y nQ), ya que en otro caso el coste global de emparejar dichos nodos
sera O(|nP| * |nQ|).



Captulo 4
124
4.5 Algoritmos branch-and-bound iterativos utilizando un
montculo para encontrar el par ms cercano

En este apartado, al igual que ocurra en el apartado 4.4, vamos a presentar una serie de
mejoras para el algoritmo iterativo basado en un montculo CPC_Monticulo_Fuerza_Bruta
en su versin branch-and-bound para obtener el par ms cercano, utilizando para ello las
mtricas entre pares de MBRs y reglas de poda vistas en el captulo 3. Tambin, al igual que
ocurra con la versin recursiva, se va a utilizar la tcnica de Barrido del Plano para el
algoritmo iterativo.
La caracterstica principal de la versin branch-and-bound iterativa es que establece como
clave de ordenacin para el montculo a MinMinDist(R
Pi
, R
Qj
), minimizando el nmero de
pares de MBRs a procesar. La estructura de datos utilizada para evitar la recursividad va a ser
un montculo mnimo, en el que el par con menor valor de MinMinDist(R
Pi
, R
Qj
) se encuentra
en la raz. Este par determina los nodos a visitar y los prximos candidatos a generar.
Debemos destacar que durante la ejecucin del algoritmo, al extraer el par situado en la
raz del montculo (que es el que tiene el mnimo valor de MinMinDist(R
Pi
, R
Qj
) hasta el
momento), puede haber ms de un par con el mismo valor de clave de ordenacin. Por tanto,
podemos aplicar los mismos criterios establecidos en
CPC_Recursivo_MINMAXDIST_MINMINDIST_Ordenado para el tratamiento de
empates sobre el montculo a nivel global, a los pares de MBRs que tengan el mismo valor de
MinMinDist(R
Pi
, R
Qj
) que el par situado en la raz del montculo en el momento de extraerlo
para ser procesado.
Al igual que ocurra con la versin recursiva, cuanto mayor sea el grado de solape entre los
conjuntos de objetos indexados mediante R*-trees, mayor ser la probabilidad de que haya
muchos pares con MinMinDist(R
Pi
, R
Qj
) igual a 0 y que estn almacenados en el montculo
durante la ejecucin del algoritmo. Esta situacin puede provocar que el algoritmo sea ms
lento al devolver los resultados. Por consiguiente, se hace necesario buscar un compromiso
entre el tratamiento de pares con el mismo valor de MinMinDist(R
Pi
, R
Qj
) a nivel global sobre
el montculo (en CPC_Recursivo_MINMAXDIST_MINMINDIST_Ordenado dicho
tratamiento se hacia a nivel local sobre la lista LISTAMINMINDIST) y el grado de solape
entre los objetos indexados en los R*-trees, para que el tiempo de respuesta del algoritmo no
se vea afectado de manera notable por dicho tratamiento.

4.5.1 Algoritmo branch-and-bound iterativo MINMINDIST
utilizando un montculo

La primera mejora del algoritmo CPC_Monticulo_Fuerza_Bruta para la consulta del par
ms cercano consiste en hacer uso del teorema 3.4 (regla de poda 1) y podar las ramas de
ambos R*-trees que verifiquen MinMinDist(R
Pi
, R
Qj
) > parMasCercano.distancia, al igual que
Algoritmos para la realizacin de la consulta del par ms cercano utilizando R*-trees
125
ocurra con CPC_Recursivo_MINMINDIST en la versin recursiva. Por este motivo, se
insertan en el montculo todos los pares de MBRs procedentes de la combinacin de dos
nodos internos de ambos R*-trees que verifiquen MinMinDist(R
Pi
, R
Qj
)
parMasCercano.distancia. Otra mejora consiste en extraer todos los pares situados en la raz
del montculo mientras M.obtenerMinimo().distancia parMasCercano.distancia, y detenerse
si se verifica lo contrario. A esta primera versin iterativa que utiliza un montculo, la
denominaremos CPC_Monticulo_MINMINDIST y los pasos CPCM2 y CPCM4 del
algoritmo CPC_Monticulo_Fuerza_Bruta ahora deberan ser:
CPCM2 Si se accede a un par de nodos internos (nP y nQ), calcular MinMinDist(R
Pi
,
R
Qj
) para cada posible par de MBRs (R
Pi
, R
Qj
) e insertar en el montculo todos
los pares de MBRs (R
Pi
, R
Qj
) que verifiquen la condicin de que
MinMinDist(R
Pi
, R
Qj
) parMasCercano.distancia.
CPCM4 Si el montculo est vaco o M.obtenerMinimo().distancia >
parMasCercano.distancia, entonces parar.
El par de objetos ms cercano requerido es el que se corresponde con el valor final de
distancia para parMasCercano.
CPC_Monticulo_MINMINDIST(RaizP, RaizQ: R_nodo)
01 M = crearMonticulo();
02 parMasCercano.distancia = ;
03 for every entrada p
i
de RaizP do
04 for every entrada q
j
de RaizQ do
05 if MinMinDist(p
i
.MBR, q
j
.MBR) parMasCercano.distancia then
06 M.insertarElemento(MinMinDist(p
i
.MBR, q
j
.MBR), p
i
.direccion, q
j
.direccion);
07 endif
08 enddo
09 enddo
10 while (not(M.estaVacio())) do
11 if M.obtenerMinimo().distancia parMasCercano.distancia then
12 Elem = M.eliminarMinimo();
13 nP = LeerNodo(Elem.direccion_nP);
14 nQ = LeerNodo(Elem.direccion_nQ);
15 if nP and nQ son nodos INTERNOS then
16 for every entrada p
i
de nP do
17 for every entrada q
j
de nQ do
18 if MinMinDist(p
i
.MBR, q
j
.MBR) parMasCercano.distancia then
19 M.insertarElemento(MinMinDist(p
i
.MBR, q
j
.MBR), p
i
.direccion, q
j
.direccion);
20 endif
21 enddo
22 enddo
23 else
24 for every entrada p
i
de nP do
25 for every entrada q
j
de nQ do
26 dist = MinMinDist(p
i
.MBR, q
j
.MBR);
27 if dist parMasCercano.distancia then
28 parMasCercano.distancia = dist;
29 parMasCercano.parObjetos = (p
i
, q
j
);
30 endif
31 enddo
32 enddo
33 endif
Captulo 4
126
34 else
35 M.hacerVacio();
36 endif
37 enddo
38 M.destruirMonticulo();
39 return parMasCercano;

4.5.2 Algoritmo branch-and-bound iterativo
MINMAXDIST_MINMINDIST utilizando un montculo

Un refinamiento para el algoritmo CPC_Monticulo_MINMINDIST para la consulta del par
ms cercano, al igual que para CPC_Recursivo_MINMAXDIST_MINMINDIST en la
versin recursiva, consiste en intentar minimizar a nivel local el valor de
parMasCercano.distancia utilizando el teorema 3.5 (regla de poda 2), produciendo un nmero
menor de inserciones en el montculo M. Al algoritmo lo vamos a denominar
CPC_Monticulo_MINMAXDIST_MINMINDIST y el paso CPCM2 respecto del
algoritmo CPC_Monticulo_MINMINDIST ahora debera ser:
CPCM2 Si se accede a un par de nodos internos (nP y nQ), calcular el mnimo
MinMaxDist(R
Pi
, R
Qj
) para cada posible par de MBRs (R
Pi
, R
Qj
), y si es menor
que parMasCercano.distancia, actualizar parMasCercano.distancia. Calcular
MinMinDist(R
Pi
, R
Qj
) para cada posible par de MBRs (R
Pi
, R
Qj
) e insertar en el
montculo todos los pares de MBRs (R
Pi
, R
Qj
) que verifiquen: MinMinDist(R
Pi
,
R
Qj
) parMasCercano.distancia.
El par de objetos ms cercano requerido es el que se corresponde con el valor final de la
distancia para parMasCercano.
CPC_Monticulo_MINMAXDIST_MINMINDIST(RaizP, RaizQ: R_nodo)
01 M = crearMonticulo();
02 parMasCercano.distancia = ;
03 minimizarMINMAXDIST(RaizP, RaizQ, parMasCercano);
04 for every entrada p
i
de RaizP do
05 for every entrada q
j
de RaizQ do
06 if MinMinDist(p
i
.MBR, q
j
.MBR) parMasCercano.distancia then
07 M.insertarElemento(MinMinDist(p
i
.MBR, q
j
.MBR), p
i
.direccion, q
j
.direccion);
08 endif
09 enddo
10 enddo
11 while (not(M.estaVacio())) do
12 if M.obtenerMinimo().distancia parMasCercano.distancia then
13 Elem = M.eliminarMinimo();
14 nP = LeerNodo(Elem.direccion_nP);
15 nQ = LeerNodo(Elem.direccion_nQ);
16 if nP and nQ son nodos INTERNOS then
17 minimizarMINMAXDIST(nP, nQ, parMasCercano);
18 for every entrada p
i
de nP do
19 for every entrada q
j
de nQ do
20 if MinMinDist(p
i
.MBR, q
j
.MBR) parMasCercano.distancia then
Algoritmos para la realizacin de la consulta del par ms cercano utilizando R*-trees
127
21 M.insertarElemento(MinMinDist(p
i
.MBR, q
j
.MBR), p
i
.direccion, q
j
.direccion);
22 endif
23 enddo
24 enddo
25 else
26 for every entrada p
i
de nP do
27 for every entrada q
j
de nQ do
28 dist = MinMinDist(p
i
.MBR, q
j
.MBR);
29 if dist parMasCercano.distancia then
30 parMasCercano.distancia = dist;
31 parMasCercano.parObjetos = (p
i
, q
j
);
32 endif
33 enddo
34 enddo
35 endif
36 else
37 M.hacerVacio();
38 endif
39 enddo
40 M.destruirMonticulo();
41 return parMasCercano;
donde la funcin minimizarMINMAXDIST viene dada por el siguiente algoritmo:
minimizarMINMAXDIST(nP, nQ: R_nodo; parMasCercano: ParObjetos)
01 for every entrada p
i
de nP do
02 for every entrada q
j
de nQ do
03 if MinMaxDist(p
i
.MBR, q
j
.MBR) < parMasCercano.distancia then
04 parMasCercano.distancia = MinMaxDist(p
i
.MBR, q
j
.MBR);
05 endif
06 enddo
07 enddo

4.5.3 Algoritmo branch-and-bound iterativo
MINMAXDIST_MINMINDIST Ordenado utilizando un
montculo

Al igual que ocurra con CPC_Recursivo_MINMAXDIST_MINMINDIST_Ordenado,
una posible mejora para la versin iterativa de
CPC_Monticulo_MINMAXDIST_MINMINDIST podra ser ordenar a nivel local los pares
de MBRs (R
Pi
, R
Qj
) generados de la combinacin dos nodos internos en orden ascendente de
MinMinDist(R
Pi
, R
Qj
), e insertar en el montculo segn este orden. A esta nueva variante del
algoritmo la vamos a denominar
CPC_Monticulo_MINMAXDIST_MINMINDIST_Ordenado y el paso CPCM2 respecto
del algoritmo CPC_Monticulo_MINMAXDIST_MINMINDIST quedara de la siguiente
forma:

Captulo 4
128
CPCM2 Si se accede a un par de nodos internos (nP y nQ), calcular el mnimo
MinMaxDist(R
Pi
, R
Qj
) para cada posible par de MBRs (R
Pi
, R
Qj
), y si es menor
que parMasCercano.distancia, actualizar parMasCercano.distancia. Calcular
MinMinDist(R
Pi
, R
Qj
) y ordenar todos los posibles pares de MBRs (R
Pi
, R
Qj
) en
orden ascendente de MinMinDist(R
Pi
, R
Qj
). Siguiendo este orden, insertar en el
montculo todos los pares de MBRs (R
Pi
, R
Qj
) que verifiquen: MinMinDist(R
Pi
,
R
Qj
) parMasCercano.distancia.
El par de objetos ms cercano requerido es el que se corresponde con el valor final de la
distancia para parMasCercano.
CPC_Monticulo_MINMAXDIST_MINMINDIST_Ordenado(RaizP, RaizQ: R_nodo)
01 M = crearMonticulo();
02 parMasCercano.distancia = ;
03 minimizarMINMAXDIST(RaizP, RaizQ, parMasCercano);
04 insertarMonticuloParesOrdenados(M, RaizP, RaizQ, parMasCercano);
05 while (not(M.estaVacio())) do
06 if M.obtenerMinimo().distancia parMasCercano.distancia then
07 Elem = M.eliminarMinimo();
08 nP = LeerNodo(Elem.direccion_nP);
09 nQ = LeerNodo(Elem.direccion_nQ);
10 if nP and nQ son nodos INTERNOS then
11 minimizarMINMAXDIST(nP, nQ, parMasCercano);
12 insertarMonticuloParesOrdenados(M, nP, nQ, parMasCercano);
13 else
14 for every entrada p
i
de nP do
15 for every entrada q
j
de nQ do
16 dist = MinMinDist(p
i
.MBR, q
j
.MBR);
17 if dist parMasCercano.distancia then
18 parMasCercano.distancia = dist;
19 parMasCercano.parObjetos = (p
i
, q
j
);
20 endif
21 enddo
22 enddo
23 endif
24 else
25 M.hacerVacio();
26 endif
27 enddo
28 M.destruirMonticulo();
29 return parMasCercano;
donde la funcin insertarMonticuloParesOrdenados viene dada por el siguiente algoritmo:
insertarMonticuloParesOrdenados(M: Monticulo; nP, nQ: R_nodo; parMasCercano: ParObjetos)
01 Total = nP.numeroDeEntradas * nQ.numeroDeEntradas;
02 Crear_Lista(LMMD, Total);
03 for every entrada p
i
de nP do
04 for every entrada q
j
de nQ do
05 t = (i * nQ.numeroDeEntradas) + j;
06 LMMD[t].MinMinDist = MinMinDist(p
i
.MBR, q
j
.MBR);
07 LMMD[t].direccion_nP = p
i
.direccion;
08 LMMD[t].direccion_nQ = q
j
.direccion;
09 if MinMaxDist(p
i
.MBR, q
j
.MBR) < parMasCercano.distancia then
10 parMasCercano.distancia = MinMaxDist(p
i
.MBR, q
j
.MBR);
Algoritmos para la realizacin de la consulta del par ms cercano utilizando R*-trees
129
11 endif
12 enddo
13 enddo
14 Ordenar_Lista(LMMD, 0, (Total 1));
15 t = 0;
16 while ((LMMD[t].MinMinDist parMasCercano.distancia) and (t < Total)) do
17 M.insertarElemento(LMMD[t].MinMinDist, LMMD[t].direccion_nP, LMMD[t].direccion_nQ);
18 t = t +1;
19 enddo
20 Destruir_Lista(LMMD);
En esta variante del algoritmo iterativo utilizando un montculo podemos llevar a cabo el
tratamiento sobre pares de MBRs que tengan el mismo valor MinMinDist(R
Pi
, R
Qj
), tanto a
nivel global sobre el montculo mnimo principal como a nivel local sobre la lista de pares
LMMD, utilizando para ello los mismos criterios establecidos en
CPC_Recursivo_MINMAXDIST_MINMINDIST_Ordenado. Es importante estudiar cul
es el mejor criterio a aplicar, siempre y cuando el tiempo de respuesta del algoritmo no se vea
afectado notablemente.
Al igual que ocurra con
CPC_Recursivo_MINMAXDIST_MINMINDIST_Ordenado_M podemos organizar
LMMD como un montculo mnimo local que utiliza como clave de ordenacin a
MinMinDist(R
Pi
, R
Qj
), dando lugar a
CPC_Monticulo_MINMAXDIST_MINMINDIST_Ordenado_M. Por tanto, la funcin
insertarMonticuloParesOrdenadosM viene dada ahora por el siguiente algoritmo:
insertarMonticuloParesOrdenadosM(M: Monticulo; nP, nQ: R_nodo; parMasCercano: ParObjetos)
01 Total = nP.numeroDeEntradas * nQ.numeroDeEntradas;
02 LMMD = crearMonticulo(Total);
03 for every entrada p
i
de nP do
04 for every entrada q
j
de nQ do
05 LMMD.insertarElemento(MinMinDist(p
i
.MBR, q
j
.MBR), p
i
.direccion, q
j
.direccion);
06 if MinMaxDist(p
i
.MBR, q
j
.MBR) < parMasCercano.distancia then
07 parMasCercano.distancia = MinMaxDist(p
i
.MBR, q
j
.MBR);
08 endif
09 enddo
10 enddo
11 while ((LMMD.obtenerMinimo().distancia parMasCercano.distancia) and (not(LMMD.estaVacio()))) do
12 Elem = LMMD.eliminarMinimo();
13 M.insertarElemento(Elem.MinMinDist, Elem.direccion_nP, Elem.direccion_nQ);
14 enddo
15 LMMD.destruirMonticulo();





Captulo 4
130
4.5.4 Algoritmo branch-and-bound iterativo utilizando la tcnica
de Barrido del Plano y un montculo

La ltima mejora del algoritmo iterativo utilizando un montculo para encontrar el par ms
cercano es aplicar la tcnica de Barrido del Plano [PrS85] (reducir el tiempo de respuesta) y
consiste en ordenar (ascendente o descendentemente) los MBRs de los nodos internos de
ambos R*-trees y despus barrer el plano de izquierda a derecha sobre uno de los ejes (eje de
barrido). La aplicacin de esta tcnica sobre el algoritmo CPC_Monticulo_MINMINDIST
es muy similar a la vista en CPC_Recursivo_Barrido_Plano en la versin recursiva. Por
ello, a esta variante la llamamos CPC_Monticulo_Barrido_Plano y el paso CPCM2
respecto del algoritmo CPC_Monticulo_MINMINDIST debera ser:
CPCM2 Si se accede a un par de nodos internos(nP y nQ), ordenar ambos nodos segn
los criterios del eje y direccin de barrido [SML00]. Escoger un MBR pivote
que no haya sido procesado hasta el momento de nP o nQ, y emparejarlo con
los restantes MBRs no marcados del otro nodo. Insertar en el montculo todos
los pares de MBRs (R
Pi
, R
Qj
) que verifiquen las dos siguientes condiciones:
MinMinDist(R
Pi
, R
Qj
, ejeBarrido) parMasCercano.distancia y
MinMinDist(R
Pi
, R
Qj
) parMasCercano.distancia (donde R
Pi
o R
Qj
ser el
MBR pivote). Una vez emparejado el MBR pivote con todos los MBRs del otro
nodo, se marca como procesado y continuamos el mismo esquema hasta que
todos los MBRs de nP nQ hayan sido procesados.
El par de objetos ms cercano requerido es el que se corresponde con el valor final de la
distancia para parMasCercano.
CPC_Monticulo_Barrido_Plano(RaizP, RaizQ: R_nodo)
01 M = crearMonticulo();
02 parMasCercano.distancia = ;
03 insertarMonticuloParesBarridoPlano(M, RaizP, RaizQ, parMasCercano);
04 while (not(M.estaVacio())) do
05 if M.obtenerMinimo().distancia parMasCercano.distancia then
06 Elem = M.eliminarMinimo();
07 nP = LeerNodo(Elem.direccion_nP);
08 nQ = LeerNodo(Elem.direccion_nQ);
09 if nP and nQ son nodos INTERNOS then
10 insertarMonticuloParesBarridoPlano(M, nP, nQ, parMasCercano);
11 else
12 for every entrada p
i
de nP do
13 for every entrada q
j
de nQ do
14 dist = MinMinDist(p
i
.MBR, q
j
.MBR);
15 if dist parMasCercano.distancia then
16 parMasCercano.distancia = dist;
17 parMasCercano.parObjetos = (p
i
, q
j
);
18 endif
19 enddo
20 enddo
21 endif
22 else
23 M.hacerVacio();
Algoritmos para la realizacin de la consulta del par ms cercano utilizando R*-trees
131
24 endif
25 enddo
26 M.destruirMonticulo();
27 return parMasCercano;
donde la funcin insertarMonticuloParesBarridoPlano viene dada por el siguiente
algoritmo:
insertarMonticuloParesBarridoPlano(M: Monticulo; nP, nQ: R_nodo; parMasCercano: ParObjetos)
01 Ordenar_Nodo(nP, ejeBarrido, direccionBarrido);
02 Ordenar_Nodo(nQ, ejeBarrido, direccionBarrido);
03 i = 0;
04 j = 0;
05 while ((i < nP.numeroDeEntradas) and (j < nQ.numeroDeEntradas)) do
06 if (nP.p
i
.MBR.min[ejeBarrido] < nQ.q
j
.MBR.min[ejeBarrido]) then
07 k = j;
08 while (k < nQ.numeroDeEntradas) do
09 if MinMinDist(nP.p
i
.MBR, nQ.q
k
.MBR, ejeBarrido) parMasCercano.distancia then
10 if MinMinDist(nP.p
i
.MBR, nQ.q
k
.MBR) parMasCercano.distancia then
11 M.insertarElemento(MinMinDist(nP.p
i
.MBR, nQ.q
k
.MBR), nP.p
i
.direccion,
nQ.q
k
.direccion);
12 endif
13 else
14 break;
15 endif
16 k = k + 1;
17 enddo
18 i = i + 1;
19 else
20 k = i;
21 while (k < nP.numeroDeEntradas) do
22 if MinMinDist(nP.p
k
.MBR, nQ.q
j
.MBR, ejeBarrido) parMasCercano.distancia then
23 if MinMinDist(nP.p
k
.MBR, nQ.q
j
.MBR) parMasCercano.distancia then
24 M.insertarElemento(MinMinDist(nP.p
k
.MBR, nQ.q
j
.MBR), nP.p
k
.direccion,
nQ.q
j
.direccion);
25 endif
26 else
27 break;
28 endif
29 k = k + 1;
30 enddo
31 j = j + 1;
32 endif
33 enddo
Como en el caso del algoritmo CPC_Recursivo_Barrido_Plano, en el algoritmo
CPC_Monticulo_Barrido_Plano a nivel de hojas (lneas 12-20), en lugar de combinar todas
las entradas de un nodo hoja del R*-tree R
P
(nP) con todas las entradas de un nodo hoja del
R*-tree R
Q
(nQ), se puede aplicar tambin la tcnica de Barrido del Plano descartando
posibles pares segn MinMinDist slo sobre ejeBarrido.

Captulo 4
132
4.5.5 Algoritmo branch-and-bound iterativo basado en un
recorrido en anchura y utilizando una lista de montculos

La estructura de datos principal para la implementacin de la versin iterativa del algoritmo
que obtiene el par ms cercano siguiendo un recorrido en anchura es una lista de montculos
mnimos por niveles basada en la altura de los R*-trees (Figura 4.9). Los elementos de cada
montculo mnimo estn formados por un par de MBRs, uno de cada ndice espacial R*-tree
de entrada, R
P
y R
Q
. En realidad esta nueva estructura consiste en dividir el montculo global
de los algoritmos iterativos anteriores en una lista de montculos por niveles. El
procesamiento de esta nueva estructura de datos se hace nivel a nivel, con la condicin de que
para procesar el montculo del nivel siguiente, el montculo del nivel actual debe estar
completamente vaco o la distancia del par de MBRs situado en la raz del montculo mnimo
en el nivel actual es estrictamente mayor que parMasCercano.distancia.

Altura 1
L
I
S
T
A
M
O
N
T
I
C
U
L
O
S

Altura 2
Altura 3
.
.
.

1
0
Ningn montculo
M
altura -1

M
altura -2

M
altura -3

M
1

.
.
.


Figura 4.9 Estructura de una lista de montculos mnimos organizada por niveles.
Debemos destacar que los pares formados por elementos de las hojas de los rboles se
combinan entre ellos para encontrar el par ms cercano pero no se insertan en el montculo de
nivel 0, el cual permanecer siempre vaco. Por tanto, los pares que se almacenan en la lista
de montculos son siempre de la forma MBR/MBR, cuyos componentes del par son entradas
de los nodos internos de cada R*-tree.
Para la variante del algoritmo que presentamos a continuacin vamos a combinar todos los
MBRs de un nodo de R
P
con todos los MBRs de un nodo de R
Q
. Aunque tambin se pueden
aplicar las mismas mejoras incorporadas en los anteriores algoritmos, como puede ser la de
Barrido del Plano [PrS85].
Al igual que ocurra con los algoritmos que siguen un recorrido en profundidad (recursivo)
o basado en una funcin de seleccin de primero el mejor (iterativo utilizando un montculo
Algoritmos para la realizacin de la consulta del par ms cercano utilizando R*-trees
133
mnimo global), las versiones CPC_Anchura_Fuerza_Bruta y
CPC_Anchura_MINMINDIST son casos particulares de
CPC_Anchura_MINMAXDIST_MINMINDIST. La descripcin por pasos (CPCA#) de
este ltimo algoritmo para dos R*-trees con las mismas alturas (altura = AlturaP = AlturaQ)
es la que se indica a continuacin:
CPCA1 Comenzar desde las races de los dos R*-trees, fijar la distancia del par ms
cercano encontrado hasta el momento, parMasCercano.distancia, a infinito (),
nivel_actual = altura 1 y crear la lista de montculos por niveles.
CPCA2 Si se accede a un par de nodos internos (nP y nQ), siendo nivel_actual 0,
calcular el mnimo MinMaxDist(R
Pi
, R
Qj
) para cada posible par de MBRs (R
Pi
,
R
Qj
), y si es menor que parMasCercano.distancia, actualizar
parMasCercano.distancia. Calcular MinMinDist(R
Pi
, R
Qj
) para cada posible par
de MBRs (R
Pi
, R
Qj
) e insertar en el montculo de la lista correspondiente al
nivel siguiente al actual (nivel_actual 1) todos los posibles pares de MBRs
(R
Pi
, R
Qj
) procedentes de los dos nodos de ambos R*-trees, siempre que
nivel_actual 1 no sea el nivel de la hojas.
CPCA3 Si se accede a dos nodos hoja (nP y nQ), siendo nivel_actual = 0, calcular la
distancia de cada posible par de objetos. Si la distancia es menor o igual que
parMasCercano.distancia, actualizar parMasCercano.distancia y
parMasCercano.parObjetos.
CPCA4 Si el montculo de nivel_actual no est vaco y MinMinDist del par situado en
la raz del montculo de nivel_actual es menor o igual que
parMasCercano.distancia, entonces obtener dicho par y repetir el algoritmo
desde CPCA2 para dicho par.
CPCA5 Si todos los montculos de la lista estn vacos, entonces parar. En caso
contrario, nivel_actual = nivel_actual 1 y obtener el par situado en la raz del
montculo del nuevo nivel_actual, repitiendo el algoritmo desde CPCA2 para
dicho par.
El par de objetos ms cercano requerido es el que se corresponde con el valor final de
distancia para parMasCercano.
CPC_Anchura_MINMAXDIST_MINMINDIST(RaizP, RaizQ: R_nodo; AlturaP: Entero)
01 LM = crearMonticulo(AlturaP);
02 parMasCercano.distancia = ;
03 minimizarMINMAXDIST(RaizP, RaizQ, parMasCercano);
04 for every entrada p
i
de RaizP do
05 for every entrada q
j
de RaizQ do
06 if MinMinDist(p
i
.MBR, q
j
.MBR) parMasCercano.distancia then
07 LM.insertarElemento(AlturaP 1, MinMinDist(p
i
.MBR, q
j
.MBR), p
i
.direccion, q
j
.direccion);
08 endif
09 enddo
10 enddo
11 nivel_actual = AlturaP 1;
12 while (nivel_actual > 0) do
13 while (not(LM.estaVacio(nivel_actual))) do
Captulo 4
134
14 if LM.obtenerMinimo(nivel_actual).distancia parMasCercano.distancia then
15 Elem = LM.eliminarMinimo(nivel_actual);
16 nP = LeerNodo(Elem.direccion_nP);
17 nQ = LeerNodo(Elem.direccion_nQ);
18 if (nivel_actual 1) 0 then
19 minimizarMINMAXDIST(nP, nQ, parMasCercano);
20 for every entrada p
i
de nP do
21 for every entrada q
j
de nQ do
22 if MinMinDist(p
i
.MBR, q
j
.MBR) parMasCercano.distancia then
23 LM.insertarElemento(nivel_actual 1, MinMinDist(p
i
.MBR, q
j
.MBR), p
i
.direccion,
q
j
.direccion);
24 endif
25 enddo
26 enddo
27 else
28 for every entrada p
i
de nP do
29 for every entrada p
i
de nQ do
30 dist = MinMinDist(p
i
.MBR, q
i
.MBR);
31 if dist parMasCercano.distancia then
32 parMasCercano.distancia = dist;
33 parMasCercano.parObjetos = (p
i
, q
j
);
34 endif
35 enddo
36 enddo
37 endif
38 else
39 LM.hacerVacio(nivel_actual);
40 endif
41 enddo
42 nivel_actual = nivel_actual 1;
43 enddo
44 LM.destruirMonticulo(AlturaP);
45 return parMasCercano;
Como hemos visto en la versin recursiva (siguiendo un patrn de recorrido en
profundidad) y en la que hemos utilizado un montculo mnimo global (recorrido basado en
una funcin de seleccin de primero el mejor), en esta nueva alternativa basada en un
recorrido en anchura, podemos aplicar de igual forma las mismas tcnicas de optimizacin:
ordenar todos los pares de MBRs formados por la combinacin de dos nodos internos segn
su MinMinDist y la tcnica de Barrido del Plano [PrS85]. La aplicacin de estas dos tcnicas
dara lugar a los siguientes algoritmos:
CPC_Anchura_MINMAXDIST_MINMINDIST_Ordenado
(CPC_Anchura_MINMAXDIST_MINMINDIST_Ordenado_M) y
CPC_Anchura_Barrido_Plano. Si analizamos cada uno de los casos, para obtener
CPC_Anchura_MINMAXDIST_MINMINDIST_Ordenado, en lugar de las lneas 20-26
deberamos llamar a la funcin insertarMonticuloParesOrdenados(LM, nivel, nP, nQ,
parMasCercano). Si deseamos obtener el algoritmo
CPC_Anchura_MINMAXDIST_MINMINDIST_Ordenado_M, debemos llamar a la
funcin insertarMonticuloParesOrdenados_M(LM, nivel, nP, nQ, parMasCercano). Por
ltimo, si nuestro objetivo es conseguir la variante CPC_Anchura_Barrido_Plano, debemos
invocar a la funcin insertarMonticuloParesBarridoPlano(LM, nivel, nP, nQ,
parMasCercano).
Algoritmos para la realizacin de la consulta del par ms cercano utilizando R*-trees
135
Adems, debemos destacar que durante la ejecucin del algoritmo, al extraer el par situado
en la raz del montculo en un nivel determinado (que es el que tiene el mnimo valor de
MinMinDist(R
Pi
, R
Qj
) hasta el momento), puede haber ms de un par con el mismo valor de
clave de ordenacin (MinMinDist). Por tanto, podemos aplicar los mismos ocho criterios
establecidos en CPC_Recursivo_MINMAXDIST_MINMINDIST_Ordenado para el
tratamiento de empates sobre los montculos en cada nivel.
Al igual que ocurra con la versin iterativa que utiliza un montculo a nivel global
(recorrido basado en una funcin de seleccin de primero el mejor), cuanto mayor sea el
grado de solape entre los conjuntos de objetos indexados mediante R*-trees, mayor ser la
probabilidad de que haya muchos pares con MinMinDist(R
Pi
, R
Qj
) igual a 0 y que estn
almacenados y distribuidos en los montculos por niveles durante la ejecucin del algoritmo.
Esta situacin puede provocar que el algoritmo sea ms lento al devolver los resultados. Por
consiguiente, se hace necesario buscar un compromiso entre el tratamiento de pares con el
mismo valor de MinMinDist(R
Pi
, R
Qj
) sobre los montculos a nivel local y el grado de solape
entre los objetos indexados en los R*-trees, para que el tiempo de respuesta del algoritmo no
se vea afectado de manera notable por dicho tratamiento.

4.6 Comparativa con otros algoritmos que determinan el
par ms cercano utilizando R*-trees

Como hemos visto en apartados anteriores, [HjS98, SML00] son los nicos trabajos
publicados hasta el momento que proponen algoritmos para la consulta de los K pares ms
cercanos utilizando R*-trees como mtodo de indexacin. En [HjS98] se presenta un
algoritmo incremental e iterativo para resolver el Join Basado en Distancias. Una aplicacin
directa de esta operacin es encontrar los K pares ms cercanos almacenados en dos ndices
arbreos multidimensionales basados en MBRs (rectngulos minimales), donde el par ms
cercano se obtiene como un caso particular de K (K = 1). En [SML00] se presentan varias
mejoras para el algoritmo incremental e iterativo introducido en [HjS98], adems de un
algoritmo para el Join K-Distancia utilizando ndices R*-trees. Entre dichas mejoras destaca
que para combinar los elementos de los nodos de los rboles utilizan tcnicas como la
expansin bidireccional de los nodos (Simultaneous en [HjS98]) y el Barrido del Plano
[PrS85]. Tambin, optimiza la tcnica de Barrido del Plano introduciendo los conceptos de eje
y direccin de barrido. Adems, propone un algoritmo adaptativo multietapa incremental para
el join K-distancia y para el join basado en distancias incremental. Debido a que [SML00] es
una mejora de [HjS98], la consulta del par ms cercano se plantea tambin como un caso
particular de K (K = 1).
Nosotros planteamos la consulta del par ms cercano como un caso especial caracterizado
por la mtrica MinMaxDist entre MBRs, y no como la aplicacin del algoritmo para un caso
particular de K (K = 1). Aunque, como veremos ms adelante, al tratar la extensin para
determinar el algoritmo que devuelva como resultado los K pares ms cercanos, podemos
obtener el par ms cercano (K = 1) sin utilizar MinMaxDist y s utilizando MaxMaxDist.
Captulo 4
136
En [HJS98, SML00] para realizar la operacin de join basado en distancias incremental
que determina el par ms cercano, utilizan como ncleo para su funcionamiento una cola de
prioridad (implementada como un montculo), donde cada elemento es un par formado por un
componente del R*-tree R
P
y otro del R*-tree R
Q
. Por este motivo, vamos a establecer una
comparativa con nuestros algoritmos iterativos basados en un montculo mnimo global o en
una lista de montculos mnimos para la determinacin del par ms cercano, en base a una
serie de parmetros representativos y que mostramos en la siguiente tabla.

Parmetro Algoritmos de [HjS98, SML00] Algoritmos branch-and-bound
basados en montculos
Forma de ejecucin Iterativos. Iterativos.
Forma de devolver el
resultado
Incremental. Devuelve los pares uno a
uno en orden ascendente de distancia,
proporcionando al usuario parte del
resultado antes de la finalizacin del
algoritmo. La consulta puede
detenerse en cualquier momento y
luego continuar sin necesidad de
volver a ejecutarla desde el principio.
No Incremental. Devuelve todos los
pares (K) juntos al terminar el algoritmo.
Si el algoritmo se detiene antes de su
finalizacin, puede que los K pares
obtenidos hasta ese momento no sean los
ms cercanos. Si obtenemos los K pares
ms cercanos y deseamos obtener los
K+1, debemos ejecutar el algoritmo
desde el principio.
Tipo de algoritmo branch-
and-bound
Recorrido basado en funcin de
seleccin de primero el mejor (mnima
distancia entre objetos).
Recorrido basado en una funcin de
seleccin de primero el mejor
(MinMinDist), utilizando un montculo
mnimo global.
Recorrido en anchura, caracterizado por
una lista de montculos por niveles.
Estructura del montculo Esquema hbrido Memoria/Disco. Montculo almacenado en memoria.
Tipo de pares insertados en
el montculo
MBR/MBR, MBR/OBJ, OBJ/MBR y
OBJ/OBJ.
MBR/MBR.
Tratamiento de empates en
el montculo
[HjS98]: dos polticas para el
tratamiento de empates.
Varias polticas para dicho tratamiento
(8), adems de no considerar ningn
tratamiento.
Recorrido de los R*-trees [HjS98]: tres polticas para recorrer
los R*-trees (Basic, Even y
Simultaneous).
[SML00]: slo una (bidireccional),
que es equivalente a la poltica
Simultaneous de [HjS98].
Slo una poltica, recorrido simultneo
de ambos R*-trees, sin dar prioridad a
ninguno de los rboles.
Cota superior para el
clculo del par ms
cercano
[HjS98]: calcula y actualiza Dmax
utilizando una cola de prioridad extra
junto con una tabla hash.
[SML00]: adems de las propuestas
hechas en [HjS98] utiliza otra cola de
prioridad para aplicar una estrategia de
poda ms agresiva actualizando Emax
y Dmax.
parMasCercano.distancia se actualiza en
funcin del mnimo valor de
MinMaxDist cuando se procesan pares de
MBRs en nodos internos (regla de poda
2).
Procesar el algoritmo hasta
que ...
El montculo est vaco o el par ms
cercano se ha obtenido.
El montculo est vaco o el valor de
MinMinDist del par situado en la raz del
montculo sea mayor que
parMasCercano.distancia.
La lista de montculos est vaca o el
valor de MinMinDist del par situado en
la raz de todos los montculos sea mayor
que parMasCercano.distancia.
Algoritmos para la realizacin de la consulta del par ms cercano utilizando R*-trees
137
Tratamiento de la consulta
del par ms cercano
Caso particular de K (K = 1). Caso especial caracterizado por la
mtrica MinMaxDist. Aunque tambin
puede considerarse como un caso
particular de K-CPC (K = 1), como
veremos en el siguiente captulo.
Tamao de la pgina en los
experimentos
[HjS98]: 1 Kbyte.
[SML00]: 4 Kbytes.
1 Kbyte.
Tipo y dimensionalidad de
los objetos utilizados en los
experimentos
Puntos [HjS98] y lneas [SML00] en
E
(2)
.
Puntos en E
(2)
.
Tabla 4.1 Comparativa entre algoritmos iterativos, incrementales y no incrementales para
obtener el par ms cercano utilizando R*-trees como mtodo de indexacin.

4.7 Conclusiones

Branch-and-bound es una tcnica para el diseo de algoritmos que pretenden encontrar la
solucin ptima de un determinado problema. La idea principal consiste en descomponer el
problema inicial en un nmero finito de subproblemas de tamao ms pequeo, calculando
cotas relativas a dichos subproblemas con el objetivo de limitar el nmero de soluciones
posibles a examinar. Dicho proceso de descomposicin se aplica repetidamente a los
subproblemas generados, resolvindolos o podndolos hasta que se encuentra la solucin
ptima o se determina que el problema no se puede resolver. En nuestro caso utilizaremos la
tcnica branch-and-bound para encontrar el par ms cercano de dos conjuntos de objetos
almacenados en sendos R*-trees, ya que es la ms apropiada al aplicarla sobre ndices
arbreos.
Para disear algoritmos branch-and-bound eficientes que den solucin a las consultas de
los pares ms cercanos debemos tener en cuenta los siguientes aspectos:
1. Aplicacin de diferentes estrategias de bsqueda (formas de procesar la consulta segn
el recorrido de los ndices que intervienen en ella). Nosotros hemos propuesto para
resolver nuestro problema: bsqueda en profundidad, bsqueda de primero el mejor y
bsqueda en anchura combinada con primero el mejor. Para la primera utilizamos la
recursividad que proporcionan la mayora de los lenguajes de programacin, mientras
que para las otras dos utilizaremos los montculos como estructura de datos principal
ms apropiada para la implementacin iterativa sin hacer uso de la recursividad.
2. Definicin de heursticas de poda que se aplicarn en algoritmos branch-and-bound
sobre R*-trees. Dichas reglas de poda se basan en las mtricas y propiedades entre pares
de MBRs definidas en el captulo anterior (MinMinDist, MinMaxDist y MaxMaxDist).
3. Aplicacin de tcnicas que optimicen los algoritmos branch-and-bound diseados para
la consulta en cuestin, con el objetivo de reducir el nmero de accesos a disco y el
tiempo de respuesta. Entre estas tcnicas destacamos el barrido del plano adaptado a
nuestro problema.
Captulo 4
138
En este captulo, tambin hemos establecido una comparativa con otros algoritmos que
determinan el par ms cercano utilizando R*-trees [HjS98, SML00], fijando diferentes
parmetros para su caracterizacin. En ella aclaramos las principales similitudes y diferencias
de los algoritmos iterativos (basados en montculos) que presentamos en esta tesis con los
publicados anteriormente en esta lnea de investigacin.
Una vez estudiados los algoritmos branch-and-bound sobre ndices arbreos basados en
MBRs para la consulta del par ms cercano, determinar el ms eficiente de ellos, requiere un
laborioso y serio trabajo de implementacin, anlisis y evaluacin. Todo ello se realizar en el
captulo dedicado a la implementacin, donde compararemos minuciosamente las alternativas
propuestas en este captulo sobre conjuntos de datos reales indexados en R*-trees.


139


Captulo 5


EXTENSIONES DE LOS
ALGORITMOS Y DETALLES DE
IMPLEMENTACIN



5.1 Introduccin

Al igual que sucede con otras consultas basadas en distancias sobre mtodos de indexacin,
tales como la consulta en rango y la del vecino ms prximo, es preciso extender la consulta
del par ms cercano para poder aplicarla a otros casos ms especficos o ms generales. Por
ejemplo, un usuario desea conocer los 15 pares (centros tursticos, hoteles) con menor
distancia entre ellos, por tanto, es necesario disear un algoritmo que encuentre los K pares
ms cercanos y los devuelva en orden ascendente de distancia. Tambin es necesario poder
procesar R*-trees con diferentes alturas, puesto que se pueden indexar conjuntos de elementos
muy grandes y combinarse con otros ms pequeos. Por ejemplo, una consulta posible sera
encontrar los K pares (ncleos de poblacin, pantanos) ms cercanos que existen en todo el
territorio nacional, teniendo para ncleos de poblacin un gran nmero de elementos,
mientras que para pantanos el nmero es mucho menor. Otra extensin natural a nuestra
consulta en estudio sera aquella que no slo encuentra los K pares ms cercanos, sino que
devuelve todos los pares en orden ascendente en base a su distancia que se encuentran en un
rango determinado. Por ejemplo, devolver todos los pares (almacn, tienda) que se
encuentran a menos de 5 kilmetros.
Las extensiones y casos de estudio presentados en este captulo pretenden demostrar la
gran operatividad que pueden proporcionar los algoritmos estudiados en el captulo anterior.
La primera de estas extensiones es la que hace posible realizar la consulta sobre R*-trees con
diferentes alturas, presentndose para ello dos interesantes tcnicas. A continuacin, se
Captulo 5
140
propone cmo realizar la consulta del par ms cercano para el caso en que los objetos no estn
almacenados en los nodos hoja de los R*-trees, sino que stos contienen los MBRs que los
envuelven junto con punteros a registros en otro archivo externo, donde se guarda la
representacin exacta de los objetos. Despus se presenta cmo extender los algoritmos de la
consulta del par ms cercano analizados en el captulo anterior para dar solucin a la consulta
de los K pares ms cercanos, siendo esta extensin la ms interesante y de gran aplicacin.
Otra posible extensin que se plantea es obtener todos o los K pares ms cercanos que tienen
una distancia en un rango dado a priori [Dist_Min, Dist_Max]. Otro caso para el estudio sera
realizar la operacin inversa, es decir, encontrar el par ms lejano o los K pares ms lejanos
de dos conjuntos de objetos almacenados en sendos R*-trees. Por ltimo, se plantean tambin
dos operaciones que son consecuencia inmediata de la consulta del par ms cercano o de los
K pares ms cercanos: la Auto-consulta y la Semi-consulta de los pares ms cercanos. La
Auto-consulta de los pares ms cercanos consiste en combinar un conjunto de objetos de
entrada indexados en un R*-tree consigo mismo (R
P
R
Q
), para determinar cules son los
objetos ms cercanos entre s. Por otro lado, la Semi-consulta de los pares ms cercanos
calcula para cada objeto indexado en el R*-tree R
P
el objeto ms prximo indexado en el R*-
tree R
Q
.

5.2 Tratamientos para R*-trees con diferentes alturas

Una vez estudiados todos los algoritmos branch-and-bound para resolver la consulta del par
ms cercano utilizando R*-trees con la misma altura, vamos a extenderlos para el caso en que
dichos R*-trees tengan una altura diferente. Los factores principales que pueden provocar una
diferencia de altura entre dos ndices R*-trees son los siguientes: por un lado, tener diferentes
valores de los factores de ramificacin m y M (mantenindose igual la cardinalidad de los
conjuntos de datos a indexar), y por otro lado, diferente nmero de objetos a indexar en los
R*-trees (permaneciendo idnticos los factores de ramificacin). Por este motivo, estos
parmetros son muy importantes en la construccin de los R*-trees para luego realizar
consultas sobre ellos.

R
P

R
Q

R
P

R
Q

(c)
(b)
R
P

R
Q

(d)
R
P

R
Q

(a)

Figura 5.1 Posibles casos para dos R*-trees (R
P
y R
Q
) con diferentes alturas.
Extensiones de los algoritmos y detalles de implementacin
141
En la Figura 5.1 se muestran los cuatro posibles casos que se pueden presentar con dos R*-
trees (R
P
y R
Q
) que tengan diferentes alturas, y que deben ser considerados en la
implementacin de los algoritmos.
Intuitivamente, la primera aproximacin que pensamos cuando deseamos encontrar el par
ms cercano para R*-trees con diferentes alturas consiste en utilizar los mismos algoritmos
descritos para rboles que tienen la misma altura incluyendo un tratamiento especial sobre
pares de la forma MBR/OBJ y OBJ/MBR, que se encuentran en nodos del tipo interno/hoja y
hoja/interno, respectivamente.
Una primera solucin podra ser, no continuar en el algoritmo con el procesamiento de
pares de la forma MBR/OBJ y OBJ/MBR, y en su lugar realizar una consulta del vecino ms
prximo (CVP) sobre un subrbol del R*-tree con mayor altura, teniendo como elemento de
consulta a los objetos almacenados en las hojas del R*-tree de menor altura. Una vez
encontrados todos los vecinos ms prximos de cada uno de los objetos del R*-tree de menor
altura obtenemos el mnimo de ellos como el par ms cercano. Evidentemente esta misma
tcnica se puede aplicar tanto a los algoritmos recursivos como a los iterativos.
Por otro lado, si deseamos continuar con el procesamiento de pares de la forma MBR/OBJ
y OBJ/MBR nos podemos plantear seguir una de las dos siguientes tcnicas, cuyas
descripciones para los algoritmos recursivos son la que se muestran a continuacin:
La primera tcnica se denomina fijar la raz (Figuras 5.1.a y 5.1.c). La idea de esta
tcnica consiste en que cuando se llama recursivamente al algoritmo con un par de
nodos internos con diferentes niveles, se detiene la propagacin en el R*-tree del nodo
con nivel ms bajo, mientras la propagacin en el otro rbol contina, hasta que se
llegue a un par de nodos internos con el mismo nivel. Entonces, la propagacin hacia
abajo en ambos subrboles continua con normalidad igual que si tuviesen la misma
altura.
La segunda tcnica se denomina fijar las hojas (Figuras 5.1.b y 5.1.d) y trabaja de
forma opuesta. La recursividad se propaga hacia abajo de forma normal. Cuando se
llama al algoritmo con un par formado por elementos de un nodo hoja y de un nodo
interno, se detiene la propagacin en el rbol del nodo hoja, mientras que la propagacin
en el otro rbol continua normalmente.
La aplicacin de la estrategia fijar la raz para el algoritmo
CPC_Recursivo_MINMAXDIST_MINMINDIST genera como resultado el paso adicional
siguiente:
CPCR2.1 Si se accede a dos nodos (nP y nQ) que residen en diferentes niveles, calcular
el mnimo MinMaxDist(R
Pi
, R
Qj
) para cada posible par de MBRs (R
Pi
, R
Qj
),
formado por un MBR contenido en el nodo de nivel ms alto y el MBR del
nodo de nivel ms bajo. Si este mnimo es menor que
parMasCercano.distancia, actualizar parMasCercano.distancia. Calcular para
todos estos pares, MinMinDist(R
Pi
, R
Qj
). Para cada par con MinMinDist(R
Pi
,
R
Qj
) parMasCercano.distancia, hacer una llamada recursiva teniendo como
parmetros los nodos correspondientes a los MBRs del par, con la restriccin
de que un parmetro ser el nodo que reside en el nivel ms bajo (nodo raz del
Captulo 5
142
R*-tree con menor altura) y el otro ser un nodo hijo del nodo interno de
mayor nivel (nodo del R*-tree con mayor altura).
Por otro lado, la aplicacin de la estrategia fijar las hojas para el mismo algoritmo
recursivo genera como resultado el siguiente paso adicional:
CPCR2.1 Si se accede a un par con de nodos (nP y nQ), tal que sus componentes sean un
nodo hoja y un nodo interno, calcular el mnimo MinMaxDist(R
Pi
, R
Qj
) para
cada posible par de MBRs (R
Pi
, R
Qj
) formado por el MBR del nodo hoja y un
MBR del nodo interno. Si este mnimo es menor que parMasCercano.distancia,
actualizar parMasCercano.distancia. Calcular para todos estos pares,
MinMinDist(R
Pi
, R
Qj
). Para cada par con MinMinDist(R
Pi
, R
Qj
)
parMasCercano.distancia, hacer una llamada recursiva teniendo como
parmetros los nodos correspondientes a los MBRs del par, con la restriccin
de que un parmetro ser el nodo hoja (R*-tree de menor altura) y el otro ser
un hijo del nodo interno (R*-tree de mayor altura).
Como ejemplo, vamos a mostrar a continuacin el seudo-cdigo del algoritmo
CPC_Recusivo_MINMAXDIST_MINMINDIST siguiendo una poltica de fijar las hojas.
CPC_Recursivo_MINMAXDIST_MINMINDIST(nP, nQ: R_nodo; parMasCercano: ParObjetos)
01 if nP and nQ son nodos INTERNOS then
02 minimizarMINMAXDIST(nP, nQ, parMasCercano);
03 for every entrada p
i
de nP do
04 for every entrada q
j
de nQ do
05 if MinMinDist(p
i
.MBR, q
j
.MBR) parMasCercano.distancia then
06 nP = LeerNodo(p
i
.direccion);
07 nQ = LeerNodo(q
i
.direccion);
08 CPC_Recursivo_MINMAXDIST_MINMINDIST(nP, nQ, parMasCercano);
09 endif
10 enddo
11 enddo
12 else
13 if nP es un nodo INTERNO and nQ es un nodo HOJA then
14 MBRNodoHoja = obtenerMBR(nQ);
15 minimizarMINMAXDIST_Nodo_MBR(nP, MBRNodoHoja, parMasCercano);
16 for every entrada p
i
de nP do
17 if MinMinDist(p
i
.MBR, MBRNodoHoja) parMasCercano.distancia then
18 nP = LeerNodo(p
i
.direccion);
19 CPC_Recursivo_MINMAXDIST_MINMINDIST(nP, nQ, parMasCercano);
20 endif
21 enddo
22 endif
23 if nP es uno nodo HOJA and nQ es un nodo INTERNO then
24 MBRNodoHoja = obtenerMBR(nP);
25 minimizarMINMAXDIST_Nodo_MBR(nQ, MBRNodoHoja, parMasCercano);
26 for every entrada q
j
de nQ do
27 if MinMinDist(MBRNodoHoja, q
j
.MBR) parMasCercano.distancia then
28 nQ = LeerNodo(q
i
.direccion);
29 CPC_Recursivo_MINMAXDIST_MINMINDIST(nP, nQ, parMasCercano);
30 endif
31 enddo
32 endif
33 if nP and nQ son nodos HOJA then
Extensiones de los algoritmos y detalles de implementacin
143
34 for every entrada p
i
de nP do
35 for every entrada q
j
de nQ do
36 dist = MinMinDist(p
i
.MBR, q
j
.MBR);
37 if dist parMasCercano.distancia then
38 parMasCercano.distancia = dist;
39 parMasCercano.parObjetos = (p
i
, q
j
);
40 endif
41 enddo
42 enddo
43 endif
44 endif
donde la funcin minimizarMINMAXDIST_Nodo_MBR viene dada por el siguiente
algoritmo:
minimizarMINMAXDIST_Nodo_MBR(nodo: R_nodo; MBRParametro: MBR; parMasCercano: ParObjetos)
01 for every entrada n
i
de nodo do
02 if MinMaxtDist(n
i
.MBR, MBRParametro) < parMasCercano.distancia then
03 parMasCercano.distancia = MinMaxtDist(n
i
.MBR, MBRParametro);
04 endif
05 enddo
La caracterstica ms importante de este algoritmo es el tratamiento de todas las posibles
combinaciones de tipos de nodos (nodo interno y nodo hoja) para formar un par:
interno/interno, interno/hoja, hoja/interno y hoja/hoja. Tambin es importante observar cmo
se aplica la tcnica fijar las hojas en la implementacin del algoritmo (lneas 13-22 para
interno/hoja y lneas 23-32 para hoja/interno). Esta aproximacin se lleva a cabo obteniendo
el MBR del nodo hoja y combinndolo con los MBRs del nodo interno, generando pares de la
forma MBR/MBR. Adems, para realizar la llamada recursiva con pares interno/hoja y
hoja/interno, slo se leen los nodos hijos del nodo interno, cosa que no ocurre con los nodos
hoja. Para el caso de los pares interno/interno y hoja/hoja la consulta del par ms cercano se
realiza de la misma forma que si los dos R*-trees tuvieran la misma altura, tal y como hemos
estudiado en el captulo anterior.
Para los algoritmos iterativos que utilizan un montculo mnimo global y su recorrido est
basado en una funcin de seleccin de primero el mejor pueden modificarse fcilmente para
procesar R*-trees con diferentes alturas utilizando las estrategias de fijar las hojas o fijar la
raz. El paso adicional que es necesario aadir a estos algoritmos es totalmente anlogo a cada
uno de los pasos indicados anteriormente, dependiendo de la tcnica utilizada. La nica
diferencia es que se sustituye la llamada recursiva por una insercin del par en el montculo.
A continuacin, vamos a mostrar el seudo-cdigo del algoritmo iterativo utilizando un
montculo mnimo global con una estrategia de bsqueda basada en una funcin de seleccin
de primero el mejor, CPC_Monticulo_MINMAXDIST_MINMINDIST siguiendo una
poltica de fijar la raz.
CPC_Monticulo_MINMAXDIST_MINMINDIST(RaizP, RaizQ: R_nodo; AlturaP, AlturaQ: Entero)
01 M = crearMonticulo();
02 parMasCercano.distancia = ;
03 if (AlturaP 1) (AlturaQ 1) then
04 Procesar_Mayor_Arbol(RaizP, RaizQ, AlturaP, AlturaQ, parMasCercano);
05 else
06 minimizarMINMAXDIST(RaizP, RaizQ, parMasCercano);
Captulo 5
144
07 for every entrada p
i
de RaizP do
08 for every entrada q
j
de RaizQ do
09 if MinMinDist(p
i
.MBR, q
j
.MBR) parMasCercano.distancia then
10 M.insertarElemento(MinMinDist(p
i
.MBR, q
j
.MBR), p
i
.direccion, AlturaP 1,
q
j
.direccion, AlturaQ 1);
11 endif
12 enddo
13 enddo
14 endif
15 while (not(M.estaVacio())) do
16 if M.obtenerMinimo().distancia parMasCercano.distancia then
17 Elem = M.eliminarMinimo();
18 nP = LeerNodo(Elem.direccion_nP);
19 nQ = LeerNodo(Elem.direccin_nQ);
20 if (Elem.nivel_nP 1) (Elem.nivel_nQ 1) then
Procesar_Mayor_Arbol(nP, nQ, Elem.nivel_nP, Elem.nivel_nQ, parMasCercano);
21 else
22 if (Elem.nivel_nP 1) 0 and (Elem.nivel_nQ 1) 0 then
23 minimizarMINMAXDIST(nP, nQ, parMasCercano);
24 for every entrada p
i
de nP do
25 for every entrada q
j
de nQ do
26 if MinMinDist(p
i
.MBR, q
j
.MBR) parMasCercano.distancia then
27 M.insertarElemento(MinMinDist(p
i
.MBR, q
j
.MBR), p
i
.direccion,
Elem.nivel_nP 1, q
j
.direccion, Elem.nivel_nQ 1);
28 endif
29 enddo
30 enddo
31 else
32 if (Elem.nivel_nP 1) = 0 and (Elem.nivel_nQ 1) = 0 then
33 for every entrada p
i
de nP do
34 for every entrada q
j
de nQ do
35 dist = MinMinDist(p
i
.MBR, q
j
.MBR);
36 if dist parMasCercano.distancia then
37 parMasCercano.distancia = dist;
38 parMasCercano.parObjetos = (p
i
, q
j
);
39 endif
40 enddo
41 enddo
42 endif
43 endif
44 endif
45 else
46 M.hacerVacio();
47 endif
48 enddo
49 M.destruirMonticulo();
50 return parMasCercano;
donde la funcin Procesar_Mayor_Arbol viene dada por el seudo-cdigo del siguiente
algoritmo:
Procesar_Mayor_Arbol(nP, nQ: R_nodo; Altura_nP, Altura_nQ: Entero; parMasCercano: ParObjetos)
01 if (Altura_nP 1) > (Altura_nQ 1) then
02 MBRNodoHoja = obtenerMBR(nQ);
03 minimizarMINMAXDIST_Nodo_MBR(nP, MBRNodoHoja, parMasCercano);
04 for every entrada p
i
de nP do
05 if MinMinDist(p
i
.MBR, MBRNodoHoja) parMasCercano.distancia then
Extensiones de los algoritmos y detalles de implementacin
145
06 M.insertarElemento(MinMinDist(p
i
.MBR, MBRNodoHoja), p
i
.direccion, Altura_nP 1,
nQ.direccion, Altura_nQ);
07 endif
08 enddo
09 else
10 MBRNodoHoja = obtenerMBR(nP);
11 minimizarMINMAXDIST_Nodo_MBR(nQ, MBRNodoHoja, parMasCercano);
12 for every entrada q
j
de nQ do
13 if MinMinDist(MBRNodoHoja, q
j
.MBR) parMasCercano.distancia then
14 M.insertarElemento(MinMinDist(MBRNodoHoja, q
j
.MBR), nP.direccion, Altura_nP,
q
j
.direccion, Altura_nQ 1);
15 endif
16 enddo
17 endif
En este algoritmo cuyo recorrido est basado en una funcin de seleccin de primero el
mejor y los pares se almacenan en un montculo mnimo global, podemos comprobar la
manera de aplicar la tcnica fijar la raz y el tratamiento de tipos de pares de nodos
(interno/interno, interno/hoja, hoja/interno y hoja/hoja). La tcnica de fijar la raz consiste en
fijar la altura del R*-tree ms pequeo y reducir la del mayor hasta que ambos tienen la
misma altura, para despus continuar con el procesamiento de la consulta de la misma manera
que si tuvieran ambos R*-trees la misma altura. Por lo que respecta al tratamiento de los tipos
de pares de nodos se realiza de la misma manera que para la versin recursiva, solo que se
inserta un par en el montculo en lugar de realizar una llamada recursiva.
De igual forma pueden modificarse fcilmente los algoritmos que utilizan una lista de
montculos mnimos organizada por niveles (funcin de seleccin de primero el mejor en cada
uno de ellos) con un recorrido en anchura para procesar R*-trees con diferentes alturas
utilizando las estrategias de fijar las hojas o fijar la raz. El paso adicional que es necesario
aadir a estos algoritmos es totalmente anlogo a cada uno de los pasos indicados
anteriormente. La nica diferencia con respecto a los que utilizan un montculo mnimo global
es que se sustituye insercin del par en el montculo por la insercin del par en la lista de
montculos mnimos dependiendo del nivel que se est procesando.
A continuacin, vamos a mostrar el seudo-cdigo del algoritmo iterativo basado en un
recorrido en anchura utilizando una lista de montculos mnimos organizada por niveles
(estrategia de bsqueda basada en una funcin de seleccin de primero el mejor en cada uno
de ellos) CPC_Anchura_MINMAXDIST_MINMINDIST siguiendo una poltica de fijar
las hojas.
CPC_Anchura_MINMAXDIST_MINMINDIST(RaizP, RaizQ: R_nodo; AlturaP, AlturaQ: Entero)
01 maxima_Altura = max(AlturaP, AlturaQ);
02 LM = crearMonticulo(maxima_Altura);
03 parMasCercano.distancia = ;
04 minimizarMINMAXDIST(RaizP, RaizQ, parMasCercano);
05 for every entrada p
i
de RaizP do
06 for every entrada q
j
de RaizQ do
07 if MinMinDist(p
i
.MBR, q
j
.MBR) parMasCercano.distancia then
08 LM.insertarElemento(maxima_Altura 1, MinMinDist(p
i
.MBR, q
j
.MBR), p
i
.direccion,
q
j
.direccion);
09 endif
10 enddo
11 enddo
Captulo 5
146
12 nivel_actual = maxima_Altura 1;
13 nivel_P = AlturaP 1;
14 nivel_Q = AlturaQ 1;
15 while (nivel_actual > 0) do
16 while (not(LM.estaVacio(nivel_actual))) do
17 if LM.obtenerMinimo(nivel_actual).distancia parMasCercano.distancia then
18 Elem = LM.eliminarMinimo(nivel_actual);
19 nP = LeerNodo(Elem.direccion_nP);
20 nQ = LeerNodo(Elem.direccion_nQ);
21 if (nivel_P 1 0) and (nivel_Q 1 0) then
22 minimizarMINMAXDIST(nP, nQ, parMasCercano);
23 for every entrada p
i
de nP do
24 for every entrada q
j
de nQ do
25 if MinMinDist(p
i
.MBR, q
j
.MBR) parMasCercano.distancia then
26 LM.insertarElemento(nivel_actual 1, MinMinDist(p
i
.MBR, q
j
.MBR),
p
i
.direccion, q
j
.direccion);
27 endif
28 enddo
29 enddo
30 endif
31 if (nivel_P 1 0) and (nivel_Q 1 = 0) then
32 MBRNodoHoja = obtenerMBR(nQ);
33 minimizarMINMAXDIST_Nodo_MBR(nP, MBRNodoHoja, parMasCercano);
34 for every entrada p
i
de nP do
35 if MinMinDist(p
i
.MBR, MBRNodoHoja) parMasCercano.distancia then
36 LM.insertarElemento(nivel_actual 1, MinMinDist(p
i
.MBR, MBRNodoHoja),
p
i
.direccion, Elem.direccion_nQ);
37 endif
38 enddo
39 endif
40 if (nivel_P 1 = 0) and (nivel_Q 1 0) then
41 MBRNodoHoja = obtenerMBR(nP);
42 minimizarMINMAXDIST_Nodo_MBR(nQ, MBRNodoHoja, parMasCercano);
43 for every entrada q
j
de nQ do
44 if MinMinDist(MBRNodoHoja, q
j
.MBR) parMasCercano.distancia then
45 LM.insertarElemento(nivel_actual 1, MinMinDist(MBRNodoHoja, q
j
.MBR),
Elem.direccion_nP, q
j
.direccion);
46 endif
47 enddo
48 endif
49 if (nivel_P 1 = 0) and (nivel_Q 1 = 0) then
50 for every entrada p
i
de nP do
51 for every entrada q
j
de nQ do
52 dist = MinMinDist(p
i
.MBR, q
j
.MBR);
53 if dist parMasCercano.distancia then
54 parMasCercano.distancia = dist;
55 parMasCercano.parObjetos = (p
i
, q
j
);
56 endif
57 enddo
58 enddo
59 endif
60 else
61 LM.hacerVacio(nivel_actual);
62 endif
63 enddo


Extensiones de los algoritmos y detalles de implementacin
147
64 nivel_actual = nivel_actual 1;
65 if (nivel_P 1 0) and (nivel_Q 1 0) then
66 nivel_P = nivel_P 1;
67 nivel_Q = nivel_Q 1;
68 endif
69 if (nivel_P 1 0) and (nivel_Q 1 = 0) then
70 nivel_P = nivel_P 1;
71 endif
72 if (nivel_P 1 = 0) and (nivel_Q 1 0) then
73 nivel_Q = nivel_Q 1;
74 endif
75 enddo
76 LM.destruirMonticulo(maxima_Altura);
77 return parMasCercano;
Para el algoritmo branch-and-bound basado en un recorrido en anchura debemos tener en
cuenta que el nmero de niveles de la lista de montculos mnimos va a coincidir con la altura
del mayor R*-tree. En este algoritmo aplicamos la tcnica de fijar las hojas, y para ello
debemos mantener tres contadores de niveles (nivel_actual, nivel_P y nivel_Q), uno para cada
R*-tree y el otro para llevar un control sobre la lista de montculos mnimos organizada por
niveles. El algoritmo desciende por los dos rboles hasta que el ms pequeo se encuentra en
el nivel anterior a las hojas, continuando posteriormente por el ms grande hasta que ambos se
encuentran en el mismo nivel, procesando todas las entradas de las hojas de forma simultnea.

5.3 Extensin de los algoritmos para el caso en que las
hojas de los R*-trees almacenen MBRs de los objetos

Hasta ahora, hemos considerado en todos los algoritmos que los objetos (MBRs o puntos)
estn almacenados en las hojas de los R*-trees (punteros nulos), dando lugar al modelo de
organizacin primario, tal y como se muestra en la Figura 5.2.a. Pero tambin, se puede dar el
caso de que las aproximaciones (MBRs) y los punteros a las representaciones exactas de los
objetos estn almacenados en las hojas de los R*-trees, estando guardados los objetos en
archivos externos al mtodo de acceso, por ejemplo en un archivo de acceso directo. A este
ltimo le llamamos modelo de organizacin secundario y se muestra en la Figura 5.2.b. Como
ejemplo, en sistemas de bases de datos espaciales, los objetos pueden estar almacenados en
las hojas del ndice (puntos o MBRs) siguiendo un modelo de organizacin primario, o en
archivos externos donde estara guardada la geometra exacta de los objetos espaciales
siguiendo un modelo de organizacin secundario.
Captulo 5
148

(b) (a)
R*-tree R*-tree

... ...

Figura 5.2 Modelos de organizacin para almacenar objetos en un R*-tree segn [BrK94a,
BHK
+
93].
Si ahora suponemos que en las hojas de los R*-trees tenemos almacenados los MBRs de
los objetos y un puntero a la descripcin exacta de los mismos, la cual se encuentra
almacenada en otro archivo, entonces tendramos que introducir las siguientes modificaciones
en todos los algoritmos en el tratamiento a nivel de nodos hoja:
01 for every entrada p
i
de nP do
02 for every entrada q
j
de nQ do
03 if (p
i
, q
j
) es un par de objetos (MBRs o puntos) con punteros nulos then
04 dist = MinMinDist(p
i
.MBR, q
j
.MBR);
05 if (dist parMasCercano.distancia) then
06 parMasCercano.distancia = dist;
07 parMasCercano.parObjetos = (p
i
, q
j
);
08 endif
09 else
10 if (p
i
, q
j
) es un par de MBRs, cuyos punteros asociados apuntan a un par de objetos then
11 if MinMinDist(p
i
.MBR, q
j
.MBR) parMasCercano.distancia then
12 O
i
= LeerObjetoArchivoExterno(p
i
.direccion)
13 O
j
= LeerObjetoArchivoExterno(q
j
.direccion)
14 D = MinimaDistanciaEntreObjetos(O
i
, O
j
);
15 if (D parMasCercano.distancia) then
16 parMasCercano.distancia = D;
17 parMasCercano.parObjetos = (O
i
, O
j
);
18 endif
19 endif
20 endif
21 endif
22 enddo
23 enddo
En este fragmento de cdigo podemos observar que las lneas 03-09 son las mismas que
hemos incluido en los algoritmos previamente estudiados, pero en las lneas 10-18 debemos
cargar en memoria la descripcin exacta de los dos objetos en cuestin, calcular la mnima
distancia entre ellos (MinimaDistanciaEntreObjetos) segn algoritmos de geometra
computacional, para luego compararla con la distancia del par de objetos ms cercano
encontrado hasta el momento. El clculo de MinimaDistanciaEntreObjetos(O
i
, O
j
) se puede
Extensiones de los algoritmos y detalles de implementacin
149
llevar a cabo utilizando los algoritmos propuestos en [ChW83, ChW84, Ede85] si dichos
objetos son polgonos convexos, o en [GJK88, LiC91] si son objetos convexos.

5.4 Extensin de los algoritmos para la consulta de los K
pares ms cercanos

Hasta ahora slo hemos considerado los algoritmos para dar solucin a la consulta del par ms
cercano, en este apartado vamos a proponer extensiones sobre esos algoritmos para la
consulta de los K pares ms cercanos.
Para obtener los K pares ms cercanos (K-CPC, caso general del par ms cercano) de
forma no incremental debemos mantener una estructura de datos adicional a nivel global en la
que estn almacenados los K pares ms cercanos encontrados hasta el momento, y el
mecanismo de poda de MBRs se debera llevar a cabo segn la distancia del par ms lejano de
los K pares ms cercanos almacenados hasta el momento en dicha estructura de datos
adicional. Es importante indicar que esta estructura de datos es un montculo de K pares en el
que la distancia mayor es la del par situado en la raz (montculo mximo), y nosotros lo
vamos a denominar KMasCercanos. Al principio, todos los elementos de KMasCercanos
deben estar inicializados a infinito (). Debido a que vamos a utilizar dos estrategias de poda
basadas en MinMinDist y MaxMaxDist, necesitamos tener una variable que nos indique el
mnimo valor de aplicar cada una de estas dos reglas de poda, nosotros la denominaremos
distanciaPodaKCPC y representar el valor de distancia por el cual vamos a descartar pares
candidatos en los algoritmos que dan solucin a la consulta de los K pares ms cercanos. Esta
variable tiene la misma funcionalidad que parMasCercano.distancia, debiendo estar
inicializada a infinito ().
distanciaPodaKCPC
R*-tree R
P
R*-tree R
Q

K-CPC
KMasCercanos
(global)
KMasCercanos.obtenerMaximo().distancia
LISTAMxMxD
(local)

Figura 5.3 Estructuras de datos adicionales para el procesamiento de los K pares ms
cercanos (K-CPC) sobre algoritmos recursivos.
Captulo 5
150
Las mtricas MinMinDist(R
1
, R
2
) y MaxMaxDist(R
1
, R
2
), definidas en el captulo 3 se
utilizan en dos reglas bsicas que se aplican para realizar el proceso de poda en los nodos de
los R*-trees cuando se recorren desde la raz hasta las hojas segn algoritmos branch-and-
bound para encontrar los K pares ms cercanos. Las reglas son las siguientes:
1. Por el teorema 3.4. Si KMasCercanos.obtenerMaximo().distancia es la distancia
Eucldea del par ms lejano de los K pares ms cercanos encontrados hasta el momento
y coincide con distanciaPodaKCPC, entonces todos los pares de MBRs (R
Pi
, R
Qj
) tal
que R
Pi
R
P
y R
Qj
R
Q
, con distancia MinMinDist(R
Pi
, R
Qj
) estrictamente mayor que
KMasCercanos.obtenerMaximo().distancia pueden descartarse, ya que estos pares de
MBRs no incluirn otro par de objetos con distancia menor que
KMasCercanos.obtenerMaximo().distancia. Esta estrategia puede utilizarse tanto si el
nodo actual es un nodo hoja como si es un nodo interno. Esta primera regla es la misma
que se utilizaba para la consulta del par ms cercano, con la diferencia de que ahora
utilizamos distanciaPodaKCPC en lugar de parMasCercano.distancia.
2. Por el teorema 3.6, y conociendo el nivel del nodo del R*-tree que se est procesando
actualmente junto con la cota inferior del factor de ramificacin de dicho rbol (m),
podemos actualizar opcionalmente el valor de distanciaPodaKCPC para los algoritmos
recursivos basados en un recorrido en profundidad (para los algoritmos iterativos se
utiliza una tcnica ms complicada utilizando estructuras de datos adicionales a nivel
global como veremos ms adelante) de ambos R*-trees de la siguiente forma:
2.1. Calcular MaxMaxDist(R
Pi
, R
Qj
) para cada par de MBRs que se pueden formar de la
combinacin de dos nodos (nP y nQ) de dichos R*-trees y almacenarlos todos (R
Pi
,
R
Qj
, MaxMaxDist(R
Pi
, R
Qj
)) en una lista temporal auxiliar a nivel local que
denominaremos LISTAMxMxD.
2.2. Todos los pares de MBRs (R
Pi
, R
Qj
) tal que R
Pi
R
P
y R
Qj
R
Q
, de la lista temporal
LISTAMxMxD se ordenan ascendentemente en base a su valor de MaxMaxDist(R
Pi
,
R
Qj
). El mtodo de ordenacin utilizado es MergeSort, igual que ocurra con
LISTAMINMINDIST en
CPC_Recursivo_MINMAXDIST_MINMINDIST_Ordenado.
2.3. Sabiendo que el nmero mnimo de objetos almacenados en los nodos hoja que se
pueden generar de cada par de MBRs (R
Pi
, R
Qj
) situados en nodos internos en ambos
R*-trees viene dado por la expresin siguiente:
( )
( ) ( )
j
Q
i P
j i
R nivel
Q
R nivel
P Q P
m m R R X ,
Entonces, podemos determinar el i-simo elemento de la lista temporal de pares de
MBRs, LISTAMxMxD, recorrindola hasta encontrar el primer elemento que
verifique la siguiente condicin:
[ ] [ ] ( ) K MBR i LISTAMxMxD MBR i LISTAMxMxD X
Total
i
Q P

1
0
. , .
Extensiones de los algoritmos y detalles de implementacin
151
siendo Total = nP.numeroDeEntradas * nQ.numeroDeEntradas. Entonces podemos
descartar todos los pares de MBRs (R
Pi
, R
Qj
) donde R
Pi
R
P
y R
Qj
R
Q
, tal que
MinMinDist(R
Pi
, R
Qj
) > LISTAMxMxD[i].MaxMaxDist, ya que estos pares de MBRs
no incluirn otro par de objetos con distancia menor que
LISTAMxMxD[i].MaxMaxDist. Adems, si distanciaPodaKCPC se corresponde con
la distancia Eucldea del par ms lejano de los K pares ms cercanos encontrados
hasta el momento y almacenados en KMasCercanos, podemos actualizar
distanciaPodaKCPC de la siguiente forma: Si LISTAMxMxD[i].MaxMaxDist <
distanciaPodaKCPC, entonces distanciaPodaKCPC =
LISTAMxMxD[i].MaxMaxDist.
Estas reglas, junto con las definiciones, teoremas y propiedades entre dos MBRs definidas
en el captulo 3 se utilizarn como cotas para el proceso de poda en los algoritmos branch-
and-bound sobre dos R*-trees que determinan el resultado de la consulta de los K pares ms
cercanos. A continuacin mostramos la extensin del algoritmo
CPC_Recursivo_MINMAXDIST_MINMINDIST para el caso de que los dos R*-trees
tienen la misma altura y que denominamos
KCPC_Recursivo_MAXMAXDIST_MINMINDIST.
KCPC_Recursivo_MAXMAXDIST_MINMINDIST(nP, nQ: R_nodo; KMasCercanos:
MonticuloParesObjetos; distanciaPodaKCPC: Real)
01 if nP and nQ son nodos INTERNOS then
02 actualizarDistanciaPodaKCPC(nP, nQ, distanciaPodaKCPC);
03 for every entrada p
i
de nP do
04 for every entrada q
j
de nQ do
05 if MinMinDist(p
i
.MBR, q
j
.MBR) distanciaPodaKCPC then
06 nP = LeerNodo(p
i
.direccion);
07 nQ = LeerNodo(q
i
.direccion);
08 KCPC_Recursivo_MAXMAXDIST_MINMINDIST(nP, nQ, KMasCercanos,
distanciaPodaKCPC);
09 endif
10 enddo
11 enddo
12 else
13 for every entrada p
i
de nP do
14 for every entrada q
j
de nQ do
15 dist = MinMinDist(p
i
.MBR, q
j
.MBR);
16 if KMasCercanos.estaLleno() then
17 if dist distanciaPodaKCPC then
18 KMasCercanos.eliminarMaximo();
19 KMasCercanos.insertarElemento(dist, p
i
, q
j
);
20 if KMasCercanos.obtenerMaximo().distancia < distanciaPodaKCPC then
21 distanciaPodaKCPC = KMasCercanos.obtenerMaximo().distancia;
22 endif
23 endif
24 else
25 KMasCercanos.insertarElemento(dist, p
i
, q
j
);
26 endif
27 enddo
28 enddo
29 endif

Captulo 5
152
donde la funcin actualizarDistanciaPodaKCPC viene dada por el siguiente algoritmo:
actualizarDistanciaPodaKCPC(nP, nQ: R_nodo; distanciaPodaKCPC: Real)
01 Total = nP.numeroDeEntradas * nQ.numeroDeEntradas;
02 Crear_Lista(LISTAMxMxD, Total);
03 for every entrada p
i
de nP do
04 for every entrada q
j
de nQ do
05 t = (i * nQ.numeroDeEntradas) + j;
06 LISTAMxMxD[t].MaxMaxDist = MaxMaxDist(p
i
.MBR, q
j
.MBR);
07 enddo
08 enddo
09 Ordenar_Lista(LISTAMxMxD, 0, (Total 1));
10 X = 0;
11 i = 0;
12 condicion = false;
13 while ((not(condicion)) and (i < Total)) do
14 X = X + (potencia(m
P
, nivel(nP)) * potencia(m
Q
, nivel(nQ)));
15 if (X K) then
16 condicion = true;
17 else
18 i = i +1;
19 endif
20 enddo
21 if ((X K) and (i < Total) and (LISTAMxMxD[i].MaxMaxDist < distanciaPodaKCPC)) then
22 distanciaPodaKCPC = LISTAMxMxD[i].MaxMaxDist;
23 endif
24 Destruir_Lista(LISTAMxMxD);
En el algoritmo anterior la funcin potencia(x, y) representa el resultado de realizar la
operacin x
y
, y la funcin nivel(a) indica el nivel del nodo a en un R*-tree determinado.
Es interesante destacar como ocurra en
CPC_Recursivo_MINMAXDIST_MINMINDIST_Ordenado_M, que LISTAMxMxD
puede organizarse como un montculo mnimo a nivel local utilizando como clave de
ordenacin MaxMaxDist(p
i
.MBR, q
j
.MBR), donde el tiempo empleado para insertar un
elemento y eliminar el mnimo est en O(logN) [Seg98], siendo N el nmero de elementos del
montculo (N = nP.numeroDeEntradas * nQ.numeroDeEntradas). Adems, organizando
LISTAMxMxD como un montculo mnimo evitamos realizar la operacin de ordenacin
(coste de al menos O(N * logN)) en la lnea 09 de actualizarDistanciaPodaKCPC, lo que
significa un ahorro de tiempo cuando N es grande.
Si no aplicamos la regla 2 basada en MaxMaxDist en el algoritmo anterior (funcin
actualizarDistanciaPodaKCPC en la lnea 02) obtenemos la variante del algoritmo
denominada KCPC_Recursivo_MINMINDIST (distanciaPodaKCPC =
KMasCercanos.obtenerMaximo().distancia) y que es la extensin de
CPC_Recursivo_MINMINDIST. Tambin, las otras variantes de los algoritmos recursivos
que siguen un recorrido en profundidad:
CPC_Recursivo_MINMAXDIST_MINMINDIST_Ordenado,
CPC_Recursivo_MINMAXDIST_MINMINDIST_Ordenado_M y
CPC_Recursivo_Barrido_Plano para obtener el resultado de la consulta de los K pares ms
cercanos se realizan de la misma forma que se ha indicado anteriormente, teniendo en cuenta
las caractersticas particulares de cada uno. Los algoritmos resultantes seran
KCPC_Recursivo_MAXMAXDIST_MINMINDIST_Ordenado,
Extensiones de los algoritmos y detalles de implementacin
153
KCPC_Recursivo_MAXMAXDIST_MINMINDIST_Ordenado_M y
KCPC_Recursivo_Barrido_Plano. Adems, las tcnicas estudiadas en el apartado 5.2 (fijar
la raz y fijar las hojas) para tratar R*-trees con diferentes alturas tambin se pueden extender
fcilmente a los algoritmos que devuelven los K pares ms cercanos.
Para los algoritmos iterativos que utilizan montculos (siguiendo un recorrido basado en
una funcin de seleccin de primero el mejor o un recorrido en anchura combinado con una
estrategia de bsqueda de primero el mejor) se utiliza una tcnica ms compleja para realizar
el proceso de poda sobre ramas innecesarias basada en MaxMaxDist y estructuras de datos
adicionales a nivel global.
Puesto que los algoritmos deben calcular los K pares de objetos ms cercanos, se puede
estimar la distancia mxima de los pares que han sido encontrados hasta el momento. Como
hemos dicho anteriormente, si K pares de la forma OBJ/OBJ se han seleccionado y
almacenado en un montculo mximo como los K pares ms cercanos encontrados hasta el
momento (KMasCercanos), entonces el par con la mayor distancia entre esos K pares
KMasCercanos.obtenerMaximo().distancia establecer una cota sobre la distancia necesaria
para calcular los K pares ms cercanos. No obstante, tambin se puede hacer uso de otros
tipos de pares, como los MBR/MBR, para llevar a cabo el proceso de poda.
Si denotamos a MxMxD
max
como la distancia mxima impuesta sobre los pares
MBR/MBR que se ir actualizando durante el procesamiento del algoritmo, y a MaxMaxDist
como la funcin de distancia que calcula una cota superior sobre la distancia de cualquier par
de objetos cubiertos por un par de MBRs. El objetivo es ir reduciendo MxMxD
max
(fijada
inicialmente a ) lo mximo posible, dependiendo del valor de K (nmero mximo de pares
requerido). Un par de MBRs (R
Pi
, R
Qj
) se elige para estimar MxMxD
max
si verifica que
MaxMaxDist(R
Pi
, R
Qj
) MxMxD
max
, garantizando que todos los pares OBJ/OBJ cubiertos por
(R
Pi
, R
Qj
) tendrn una distancia en el rango [0, MxMxD
max
].
El proceso para ir actualizando MxMxD
max
va a depender del valor de K, y para poder
llevarlo a cabo es necesario mantener un conjunto adicional de pares de MBRs de la forma
(R
Pi
, R
Qj
), que incluya cada uno de los pares de MBRs que se han insertado en el montculo
mnimo principal pero an no se han extrado. Este conjunto adicional de pares de MBRs va a
ser un montculo mximo a nivel global organizado de tal forma que en la raz se coloca el par
con mayor valor de MaxMaxDist(R
Pi
, R
Qj
), y nosotros vamos a denominar MMMD. Segn las
definiciones de MxMxD
max
y MMMD, podemos deducir que MxMxD
max
=
MMMD.obtenerMaximo().distancia. Por tanto, las estructuras de datos adicionales necesarias
para obtener los K pares ms cercanos utilizadas en los algoritmos iterativos son las que se
muestran en al Figura 5.4.
Captulo 5
154

distanciaPodaKCPC
R*-tree R
P
R*-tree R
Q

K-CPC
KMasCercanos
OBJ/OBJ (global)
KMasCercanos.obtenerMaximo().distancia
MMMD
MBR/MBR (global)
MxMxD
max


Figura 5.4 Estructuras de datos adicionales para el procesamiento de los K pares ms
cercanos (K-CPC) sobre algoritmos iterativos.
El proceso que actualiza MMMD (operaciones similares a las aplicadas a LISTAMxMxD,
pero en sta se ejecutan a nivel local sobre la combinacin de elementos de dos nodos) es el
siguiente:
1. Cuando un par de MBRs (R
Pi
, R
Qj
) se inserta en el montculo mnimo insercin, tambin
se inserta en MMMD. Si la insercin del par provoca que la suma de pares OBJ/OBJ
que se pueden generar (cubrir) de los que hay en ese momento en MMMD es mayor que
K, entonces borramos pares de MMMD (con el mayor valor de MaxMaxDist) hasta que
la suma sea menor o igual que K, estableciendo MxMxD
max
al valor de MaxMaxDist del
ltimo par borrado.
2. Cuando un par de MBRs (R
Pi
, R
Qj
) se extrae del montculo principal, debe borrarse
tambin de MMMD, si ste est presente.
Adems, como ocurra con el caso para los algoritmos recursivos, debido a que vamos a
utilizar dos estrategias de poda basadas en MinMinDist y MaxMaxDist, necesitamos tener una
variable global que nos indique el mnimo valor de aplicar cada una de estas tcnicas. A sta
la denominbamos distanciaPodaKCPC y representar el valor de distancia por el cual vamos
a realizar la poda en los algoritmos para dar solucin a la consulta de los K pares ms
cercanos. Esta variable tiene la misma funcionalidad que parMasCercano.distancia, debiendo
estar inicializada a infinito ().
Para poder borrar un elemento cualquiera de MMMD, incorporamos una tabla hash sobre
dicho montculo mximo para localizar de forma directa un par de MBRs determinado segn
su MaxMaxDist. Esta tabla hash est basada en una funcin hash de la forma, i =
funcion_acceso(clave), que aplicndola a una clave obtenemos un nmero entero y positivo
que nos da la posicin del elemento correspondiente dentro de dicha tabla. Para nosotros la
Extensiones de los algoritmos y detalles de implementacin
155
clave de acceso se corresponde con el valor de MaxMaxDist entre los MBRs que forman el
par. Por tanto, la ecuacin de transformacin viene dada de la siguiente forma:
Posicion = MaxMaxDist(MBR
1
, MBR
2
) mod N
donde N es el tamao introducido por el usuario para la tabla hash.
La organizacin de esta tabla hash est basada en una estructura de datos formada por un
nmero N de listas enlazadas independientes como la propuesta en [Seg98], haciendo posible
un tratamiento sencillo de las colisiones que se puedan dar para valores de clave que
coincidan en la misma posicin de la tabla hash. La estructura global asociada a MMMD
viene ilustrada en la Figura 5.5. Por tanto, incorporando esta tabla hash se pueden eliminar de
MMMD cualquier par de MBRs que se solicite sin necesidad de realizar un recorrido
secuencial sobre dicho montculo (array en memoria).

MMMD

0
Tabla_Hash
1
2
N 1

Figura 5.5 Tabla hash organizada por listas enlazadas asociada a un montculo mximo de
pares de MBRs (MMMD), utilizando como clave para la organizacin de la misma, la mtrica
MaxMaxDist.
Aplicando las reglas expuestas anteriormente, a continuacin mostramos la extensin del
algoritmo CPC_Monticulo_MINMAXDIST_MINMINDIST para el caso de que los dos
R*-trees tienen la misma altura y que denominamos
KCPC_Monticulo_MAXMAXDIST_MINMINDIST.
KCPC_Monticulo_MAXMAXDIST_MINMINDIST(RaizP, RaizQ: R_nodo; K, AlturaP: Entero)
01 M = crearMonticulo();
02 MMMD = crearMonticulo();
03 KMasCercanos = crearMonticulo(K);
04 sumaParesPosibles = 0;
05 distanciaPodaKCPC = ;
06 for every entrada p
i
de RaizP do
07 for every entrada q
j
de RaizQ do
08 if MinMinDist(p
i
.MBR, q
j
.MBR) distanciaPodaKCPC then
09 M.insertarElemento(MinMinDist(p
i
.MBR, q
j
.MBR), p
i
.direccion, p
i
.MBR, q
j
.direccion, q
j
.MBR);
10 MMMD.insertarActualizar(MaxMaxDist(p
i
.MBR, q
j
.MBR), AlturaP, p
i
.MBR, AlturaP, q
j
.MBR,
K, sumaParesPosibles, distanciaPodaKCPC);
11 endif
Captulo 5
156
12 enddo
13 enddo
14 while (not(M.estaVacio())) do
15 if M.obtenerMinimo().distancia distanciaPodaKCPC then
16 Elem = M.eliminarMinimo();
17 MMMD.eliminarActualizar(Elem.MBR_P, Elem.MBR_Q, sumaParesPosibles);
18 nP = LeerNodo(Elem.direccion_nP);
19 nQ = LeerNodo(Elem.direccion_nQ);
20 if nP and nQ son nodos INTERNOS then
21 for every entrada p
i
de nP do
22 for every entrada q
j
de nQ do
23 if MinMinDist(p
i
.MBR, q
j
.MBR) distanciaPodaKCPC then
24 M.insertarElemento(MinMinDist(p
i
.MBR, q
j
.MBR), p
i
.direccion, p
i
.MBR, q
j
.direccion,
q
j
.MBR);
25 MMMD.insertarActualizar(MaxMaxDist(p
i
.MBR, q
j
.MBR), nivel(nP), p
i
.MBR,
nivel(nQ), q
j
.MBR, K, sumaParesPosibles,
distanciaPodaKCPC);
26 endif
27 enddo
28 enddo
29 else
30 for every entrada p
i
de nP do
31 for every entrada q
j
de nQ do
32 dist = MinMinDist(p
i
.MBR, q
j
.MBR);
33 if KMasCercanos.estaLleno() then
34 if dist distanciaPodaKCPC then
35 KMasCercanos.eliminarMaximo();
36 KMasCercanos.insertarElemento(dist, p
i
, q
j
);
37 if KMasCercanos.obtenerMaximo ().distancia < distanciaPodaKCPC then
38 distanciaPodaKCPC = KMasCercanos.obtenerMaximo().distancia;
39 endif
40 endif
41 else
42 KMasCercanos.insertarElemento(dist, p
i
, q
j
);
43 endif
44 enddo
45 enddo
46 endif
47 else
48 M.hacerVacio();
49 endif
50 enddo
51 M.destruirMonticulo();
donde la funcin insertarActualizar asociada al montculo MMMD viene dada por el
siguiente algoritmo:
insertarActualizar(MaxMaxDist: Real; nivel_P: Entero; MBR_P: Rectangulo; nivel_Q: Entero; MBR_Q:
Rectangulo; K: Entero; sumaParesPosibles: Entero; distanciaPodaKCPC: Real)
01 MMMD.insertarElemento(MaxMaxDist, MBR_P, MBR_Q);
02 Tabla_Hash.insertarElemento(MaxMaxDist, MBR_P, MBR_Q);
03 sumaParesPosibles = sumaParesPosibles + (potencia(m
P
, nivel_P) * potencia(m
Q
, nivel_Q));
04 auxDmax = distanciaPodaKCPC;
05 intentarActualizarDistanciaPodaKCPC = false;
06 MMMDActualizado = true;
07 while ((not(MMMD.estaVacio())) and (MMMDActualizado)) do
08 MMMDActualizado = false;
Extensiones de los algoritmos y detalles de implementacin
157
09 Item1 = MMMD.obtenerMaximo();
10 auxSumaParesPosibles = sumaParesPosibles (potencia(m
P
, Item1.nivel_P) *
potencia(m
Q
, Item1.nivel_Q));
11 if (auxSumaParesPosibles K) then
12 Item = MMMD.eliminarMaximo();
13 Tabla_Hash.eliminarElemento(Item);
14 sumaParesPosibles = sumaParesPosibles (potencia(m
P
, Item.nivel_P) *
potencia(m
Q
, Item.nivel_Q));
15 auxDmax = Item.MaxMaxDist;
16 intentarActualizarDistanciaPodaKCPC = true;
17 MMMDActualizado = true;
18 endif
19 enddo
20 if ((intentarActualizarDistanciaPodaKCPC) and (auxDmax < distanciaPodaKCPC)) then
21 distanciaPodaKCPC = auxDmax;
22 endif
por otro lado la funcin eliminarActualizar asociada tambin al montculo MMMD viene
dada por el siguiente algoritmo:
eliminarActualizar(MBR_P: Rectangulo; MBR_Q: Rectangulo; sumaParesPosibles: Entero)
01 if (Tabla_Hash.buscarElemento(MaxMaxDist(MBR_P, MBR_Q), Item) then
02 MMMD.eliminarElemento(Item);
03 MMMD.rehacerMonticulo();
04 Tabla_Hash.eliminarElemento(Item);
05 sumaParesPosibles = sumaParesPosibles (potencia(m
P
, Item.nivel_P) * potencia(m
Q
, Item.nivel_Q));
06 endif
La extensin del algoritmo anterior para las otras variantes que utilizan un montculo segn
la poltica de primero el mejor (Ordenado y utilizando la tcnica de Barrido del Plano) es
inmediata. Al igual ocurre cuando se combinan las tcnicas de primero el mejor con un
recorrido en anchura, slo que para este caso se utiliza una lista de montculos mnimos
organizada por niveles.

5.5 Extensin de los algoritmos para obtener los K pares
ms cercanos en un rango de distancia [Dist_Min,
Dist_Max]

Otro caso de estudio como extensin de la consulta de los K pares ms cercanos que nos
podemos plantear es determinar los K pares ms cercanos que se encuentran dentro de un
rango de distancia dado a priori [Dist_Min, Dist_Max] (0 Dist_Min Dist_Max). Este
rango puede ser especificado por el usuario y determina el mnimo y el mximo de distancia
deseado para el resultado de la consulta. Las modificaciones necesarias de los algoritmos son
las siguientes:
1. No utilizar distanciaPodaKCPC como distancia por la que vamos a realizar el proceso
de poda.
Captulo 5
158
2. Si se accede a dos nodos internos (nP y nQ), no actualizar distanciaPodaKCPC
utilizando MaxMaxDist. Calcular MinMinDist(R
Pi
, R
Qj
) y propagar recursivamente hacia
abajo en los dos R*-trees slo para aquellos pares de MBRs (R
Pi
, R
Qj
) que verifiquen
MinMinDist(R
Pi
, R
Qj
) Dist_Max.
3. Si se accede a un par de nodos hoja (nP y nQ), calcular la distancia de cada posible par
de objetos. Si la distancia est en el rango [Dist_Min, Dist_Max], entonces insertar el
par en KMasCercanos y no actualizar distanciaPodaKCPC.
La Figura 5.6 ilustra las estructuras de datos necesarias para obtener los K pares ms
cercanos que estn dentro de un rango distancia dado a priori [Dist_Min, Dist_Max].

[Dist_Min, Dist_Max]
R*-tree R
P
R*-tree R
Q

K-CPC
KMasCercanos
OBJ/OBJ (global)
KMasCercanos.obtenerMaximo().distancia

Figura 5.6 Estructuras de datos adicionales para obtener los K pares ms cercanos que
estn en un rango de distancia [Dist_Min, Dist_Max].
La estructura de los algoritmos que encuentran la solucin buscada son similares a los que
determinan los K pares ms cercanos. A continuacin mostramos la extensin del algoritmo
KCPC_Recursivo_MINMINDIST para el caso de que los dos R*-trees tienen la misma
altura y que denominamos KCPC_Recursivo_RangoDistancia_MINMINDIST.
KCPC_Recursivo_RangoDistancia_MINMINDIST(nP, nQ: R_nodo; KMasCercanos:
MonticuloParesObjetos; Dist_Min, Dist_Max: Real)
01 if nP and nQ son nodos INTERNOS then
02 for every entrada p
i
de nP do
03 for every entrada q
j
de nQ do
04 if MinMinDist(p
i
.MBR, q
j
.MBR) Dist_Max then
05 nP = LeerNodo(p
i
.direccion);
06 nQ = LeerNodo(q
i
.direccion);
07 KCPC_Recursivo_RangoDistancia_MINMINDIST(nP, nQ, KMasCercanos, Dist_Min,
Dist_Max);
08 endif
09 enddo
Extensiones de los algoritmos y detalles de implementacin
159
10 enddo
11 else
12 for every entrada p
i
de nP do
13 for every entrada q
j
de nQ do
14 dist = MinMinDist(p
i
.MBR, q
j
.MBR);
15 if (Dist_Min dist) and (dist Dist_Max) then
16 if KMasCercanos.estaLleno() then
17 if (dist KMasCercanos.obtenerMaxi mo().distancia) then
18 KMasCercanos = eliminarMaximo();
19 KMasCercanos.insertarElemento(dist, p
i
, q
j
);
20 endif
21 else
22 KMasCercanos.insertarElemento(dist, p
i
, q
j
);
23 endif
24 endif
25 enddo
26 enddo
27 endif
Por otro lado, podemos desear obtener TODOS los posibles pares de objetos cuya distancia
est dentro de un intervalo [Dist_Min, Dist_Max]. En este caso, no existe un valor de K fijado
a priori, sino que ste ir variando conforme evolucione el algoritmo. Por tanto, K ser
variable y el tamao del montculo KMasCercanos tambin. Entonces, las modificaciones de
los algoritmos sern las tres que se han citado anteriormente con una consideracin adicional
referida a la gestin del montculo KMasCercanos. En el peor caso, KMasCercanos puede
crecer hasta alcanzar el producto cartesiano de todos los objetos indexados por los dos R*-
trees. Esto es, el tamao de KMasCercanos puede tener |P||Q|, donde |P| y |Q| es el nmero de
objetos P y Q indexados para dar lugar a los R*-trees R
P
y R
Q
, respectivamente. Por tanto, no
siempre es posible almacenar el montculo KMasCercanos en memoria principal y se debern
utilizar un esquema hbrido memoria/disco utilizando tcnicas basadas en la divisin del
rango, como se presentan en [HjS98, SML00].
La extensin a los algoritmos iterativos de estas variantes de la consulta es sencilla,
independientemente de que sigan una poltica de primero el mejor utilizando un montculo o
uno que combine las tcnicas de primero el mejor con un recorrido en anchura, utilizando
para ello un montculo organizado por niveles. Para realizar esto slo habra que considerar el
tratamiento especial que se hace tanto en los nodos internos como en los nodos hoja segn el
rango de distancia [Dist_Min, Dist_Max] dado como parmetro.







Captulo 5
160
5.6 Extensin de los algoritmos para realizar la consulta
del par ms lejano y de los K pares ms lejanos

Otra extensin de la consulta del par ms cercano (CPC) y de los K pares ms cercanos (K-
CPC) que nos podemos plantear es determinar el par ms lejano (de forma abreviada CPL) y
los K pares ms lejanos (cuya abreviacin sera K-CPL) de dos conjuntos de objetos
indexados por sendos R*-trees.
Definicin. Consulta del Par ms Lejano. CPL.
Dados dos conjuntos no vacos P y Q (P y Q ), la consulta del par ms lejano se
define como el siguiente conjunto:
CPL(P, Q) = {(O, O) PQ: (O
i
, O
j
) PQ {(O, O)}, d(O, O) d(O
i
, O
j
)}
En nuestro caso, todos los objetos de P y Q tienen asociado un conjunto de atributos
espaciales A
P
y A
Q
tal que los objetos espaciales O.A
P
y O.A
Q
pertenecen a E
(k)
, y d es la
distancia Eucldea.
Es decir, la Consulta del Par ms Lejano (CPL) de dos conjuntos de objetos espaciales P y
Q nos devuelve un par que tiene la distancia Eucldea ms grande entre todos los posibles
pares de objetos espaciales que pueden formarse escogiendo un objeto de P y otro objeto de
Q.
Definicin. Consulta de los K Pares ms Lejanos. K-CPL.
Dados dos conjuntos no vacos P y Q (P y Q ), la consulta de los K pares ms
lejanos se define como un conjunto conteniendo subconjuntos de PQ, cada uno de ellos con
K (1K|P||Q|) pares de objetos distintos y ordenados en ranking segn su distancia. Es
decir, como el siguiente conjunto:
K-CPL(P, Q, K) = {{(O
1
, O
1
), (O
2
, O
2
), ..., (O
K
, O
K
)} PQ; (O
i
, O
i
) (O
j
, O
j
) ij:
(O
i
, O
j
) PQ, {(O
1
, O
1
), (O
2
, O
2
), ..., (O
K
, O
K
)}, O
i
P, O
j
Q,
d(O
1
, O
1
) d(O
2
, O
2
) ... d(O
K
, O
K
) d(O
i
, O
j
)}
En este caso, al igual que para CPC, todos los objetos de P y Q tienen asociado un
conjunto de atributos espaciales A
P
y A
Q
tal que los objetos espaciales O.A
P
y O.A
Q

pertenecen a E
(k)
, y d es la distancia Eucldea.
Es decir, la Consulta del los K Pares ms Lejanos (K-CPL) de dos conjuntos de objetos
espaciales P y Q definidos en E
(k)
, nos devuelve un conjunto conteniendo subconjuntos de K
pares de objetos distintos y ordenados descendentemente segn su distancia Eucldea, y que
tienen las K distancias ms grandes entre todos los posibles pares de objetos que se pueden
formar escogiendo un objeto de P y otro objeto de Q.
Si deseamos establecer el algoritmo CPL_Recursivo_MAXMAXDIST_Ordenado para
obtener el par ms lejano, debemos tener en cuenta las siguientes consideraciones:
Extensiones de los algoritmos y detalles de implementacin
161
1. parMasLejano.distancia = 0.
2. Para nodos internos:
2.1. No debemos utilizar el mnimo de MinMaxDist como cota superior de poda.
2.2. Debemos utilizar MaxMaxDist como mtrica de distancia para la poda y no
MinMinDist, dando lugar a una lista que denominamos LISTAMAXMAXDIST.
2.3. Ordenar la nueva l ista LISTAMAXMAXDIST de mayor a menor valor de distancia
MaxMaxDist.
2.4. Llamar recursivamente a la funcin si LISTAMAXMAXDIST.MaxMaxDist[t]
parMasLejano.distancia.
3. Para nodos hoja:
3.1. Si MinMinDist(p
i
.MBR, q
j
.MBR) parMasLejano.distancia, entonces se selecciona
el par (p
i
, q
j
) como el ms lejano encontrado hasta el momento.
Si deseamos disear el algoritmo KCPL_Recursivo_MAXMAXDIST_Ordenado para
obtener los K vecinos ms lejanos, debemos tener en cuenta las siguientes consideraciones:
1. El montculo mnimo adicional que utilizamos para almacenar los K pares ms lejanos
(KMasLejanos) debe estar organizado segn las distancias de pares de objetos, estando
el par con menor distancia (el ms cercano de los K ms lejanos) en la raz del
montculo. Inicialmente, todos los elementos del montculo deben estar inicializados a
0.
2. Para nodos internos:
2.1. Debemos utilizar MaxMaxDist como mtrica de distancia para la poda y no
MinMinDist, dando lugar a una lista que denominamos LISTAMAXMAXDIST.
2.2. Ordenar la nueva lista LISTAMAXMAXDIST de mayor a menor valor de distancia
MaxMaxDist.
2.3. Llamar recursivamente a la funcin si LISTAMAXMAXDIST.MaxMaxDist[t]
KMasLejanos.obtenerMinimo().distancia.
3. Para nodos hoja:
3.1. Si MinMinDist(p
i
.MBR, q
j
.MBR) KMasLejanos.obtenerMinimo().distancia,
entonces se selecciona el par (p
i
, q
j
) para incluirlo en el montculo mnimo adicional
KMasLejanos.
Si deseamos establecer el algoritmo iterativo CPL_Monticulo_MAXMAXDIST para
obtener el par ms lejano, debemos tener en cuenta las siguientes consideraciones:
1. parMasLejano.distancia = 0.
Captulo 5
162
2. El montculo principal de pares de MBRs que se utiliza para evitar la recursividad debe
estar organizado segn mximas distancias (clave = MaxMaxDist), estando el mayor de
todos ellos en la raz del montculo (montculo mximo).
3. Procesar los elementos del montculo principal mientras Elem.MaxMaxDist
parMasLejano.distancia.
4. Para nodos internos:
4.1. No debemos utilizar el mnimo de MinMaxDist como cota superior de poda.
4.2. Debemos utilizar MaxMaxDist como mtrica de distancia para la poda y no
MinMinDist.
4.3. Insertar en el montculo principal pares de MBRs si MaxMaxDist(p
i
.MBR, q
j
.MBR)
parMasLejano.distancia.
5. Para nodos hoja:
5.1. Si MinMinDist(p
i
.MBR, q
j
.MBR) parMasLejano.distancia, entonces se selecciona
el par (p
i
, q
j
) como el ms lejano encontrado hasta el momento.
Si deseamos disear el algoritmo iterativo KCPL_Monticulo_MAXMAXDIST para
obtener los K pares ms lejanos, debemos tener en cuenta las siguientes consideraciones:
1. El montculo mnimo adicional que utilizamos para almacenar los K pares ms lejanos
(KMasLejanos) debe estar organizado segn las distancias de pares de objetos, estando
el par con menor distancia (el ms cercano de los K ms lejanos) en la raz del
montculo. Inicialmente, todos los elementos del montculo deben estar inicializados a
0.
2. El montculo principal de pares de MBRs que se utiliza para evitar la recursividad debe
estar organizado segn mximas distancias (clave = MaxMaxDist), estando el mayor de
todos ellos en la raz del montculo (montculo mximo).
3. Procesar los elementos del montculo mximo principal mientras Elem.MaxMaxDist
KMasLejanos.obtenerMinimo().distancia.
4. Para nodos internos:
4.1. Debemos utilizar MaxMaxDist como mtrica de distancia para la poda y no
MinMinDist.
4.2. Insertar en el montculo principal pares de MBRs si MaxMaxDist(p
i
.MBR, q
j
.MBR)
KMasLejanos.obtenerMinimo().distancia.
5. Para nodos hoja:
Extensiones de los algoritmos y detalles de implementacin
163
5.1. Si MinMinDist(p
i
.MBR, q
j
.MBR) KMasLejanos.obtenerMinimo().distancia,
entonces se selecciona el par (p
i
, q
j
) para incluirlo en el montculo mnimo adicional
KMasLejanos.
Para resolver esta consulta, extendiendo el algoritmo basado en un recorrido en anchura
combinado con una seleccin de primero el mejor, debemos realizar las mismas
consideraciones que para CPL_Monticulo_MAXMAXDIST y
KCPL_Monticulo_MAXMAXDIST, teniendo en cuenta que el montculo mximo principal
hay que dividirlo segn el nmero de niveles del mayor de los R*-trees que intervienen en la
consulta. El procesamiento de esta nueva estructura de datos se hace nivel a nivel, con la
condicin de que para procesar el montculo del nivel siguiente, el montculo del nivel actual
debe estar completamente vaco.

5.7 Auto-consulta de los pares ms cercanos (Auto-CPC)

Esta operacin (Auto-CPC y Auto-K-CPC) es un caso especial de la consulta del par ms
cercano (CPC) y de los K pares ms cercanos (K-CPC), donde los conjuntos de objetos que
intervienen en la consulta se refieren a la misma entidad. Es decir, que el conjunto de objetos
de entrada se combina consigo mismo (P Q y ambas entradas se corresponden con el mismo
R*-tree, R
P
R
Q
) para determinar cules son los objetos ms cercanos entre s. El esquema
bsico para esta consulta en funcin de las estructuras de datos que intervienen en ella se
muestra en la Figura 5.7.

R
P

Auto-K-CPC
KMasCercanos
OBJ/OBJ (global)
distanciaPodaKCPC
R
P

ParMasCercano.distancia
R
P
R
P

Auto-CPC

Figura 5.7 Estructuras de datos para el procesamiento de Auto-CPC y Auto-K-CPC.
Para dar solucin a esta operacin, los algoritmos presentados anteriormente pueden
modificarse de forma sencilla a nivel de nodos hoja (nP y nQ), verificando simultneamente
las siguientes restricciones sobre los pares de objetos candidatos al resultado final (p
i
, q
j
):
1. El par (p
i
, q
j
) puede incluirse en el resultado final si y slo si p
i
q
j
.
Captulo 5
164
2. El par (p
i
, q
j
) puede incluirse en el resultado final si y slo si (q
j
, p
i
) no est ya incluido
(par simtrico).
El esqueleto de la implementacin para resolver la operacin Auto-CPC, adaptando los
algoritmos de la consulta del par ms cercano, incluso para el tratamiento de R*-trees con
diferentes alturas, y para las versiones recursivas (para las variantes iterativas el tratamiento
es similar), es el siguiente:
CPC_Algoritmos(nP, nQ: R_nodo; parMasCercano: ParObjetos; autoCPC: Booleana)
01 if nP and nQ son nodos INTERNOS then
02 //
03 else
04 if nP es un nodo INTERNO and nQ es un nodo HOJA then
05 // ...
06 endif
07 if nP es uno nodo HOJA and nQ es un nodo INTERNO then
08 //
09 endif
10 if nP and nQ son nodos HOJA then
11 for every entrada p
i
de nP do
12 for every entrada q
j
de nQ do
13 dist = MinMinDist(p
i
.MBR, q
j
.MBR);
14 if (autoCPC) then
15 if dist parMasCercano.distancia then
16 if (p
i
q
j
) then
17 if (parMasCercano.parObjetos (q
j
, p
i
)) then
18 parMasCercano.distancia = dist;
19 parMasCercano.parObjetos = (p
i
, q
j
);
20 endif
21 endif
22 endif
23 else
24 if dist parMasCercano.distancia then
25 parMasCercano.distancia = dist;
26 parMasCercano.parObjetos = (p
i
, q
j
);
27 endif
28 endif
29 enddo
30 enddo
31 endif
32 endif
Para resolver la operacin Auto-K-CPC, tanto para las versiones recursivas como para las
iterativas, necesitamos una tabla hash adicional (Auto_Tabla_Hash) vinculada al montculo
mximo KMasCercanos para encontrar en l un par determinado sin la necesidad de
recorrerlo secuencialmente. Esta estructura de datos es necesaria para que se satisfaga la
segunda condicin y detectar si el simtrico de un par (q
j
, p
i
) est ya almacenado en el
montculo KMasCercanos, cuando estamos procesando el par (p
i
, q
j
), evitando almacenar
informacin duplicada.
El esquema en el que hay vinculada una tabla hash (Auto_Tabla_Hash) al montculo donde
se almacenan los K pares ms cercanos encontrados hasta el momento (KMasCercanos) es el
que se muestra en la Figura 5.8. La estructura de datos y las operaciones asociadas son iguales
Extensiones de los algoritmos y detalles de implementacin
165
a la de Tabla_Hash utilizada en los algoritmos iterativos para obtener los K pares ms
cercanos haciendo uso de la regla de poda basada en la mtrica MaxMaxDist.

KMasCercanos

0
Auto_Tabla_Hash
1
2
N 1

Figura 5.8 Tabla hash organizada por listas enlazadas vinculada a un montculo mnimo de
pares de puntos (KMasCercanos), utilizando como clave de ordenacin la distancia Eucldea
entre ellos.
El esqueleto de la implementacin de esta operacin (Auto-K-CPC) adaptando los
algoritmos recursivos de la consulta de los K pares ms cercanos es el que se muestra a
continuacin:
KCPC_Recursivos_Algoritmos(nP, nQ: R_nodo; KMasCercanos: MonticuloParesObjetos;
distanciaPodaKCPC: Real; autoCPC: Booleana)
01 if nP and nQ son nodos INTERNOS then
02 //
03 else
04 if nP es un nodo INTERNO and nQ es un nodo HOJA then
05 // ...
06 endif
07 if nP es uno nodo HOJA and nQ es un nodo INTERNO then
08 //
09 endif
10 if nP and nQ son nodos HOJA then
11 for every entrada p
i
de nP do
12 for every entrada q
j
de nQ do
13 dist = MinMinDist(p
i
.MBR, q
j
.MBR);
14 if (autoCPC) then
15 if KMasCercanos.estaLleno() then
16 if dist distanciaPodaKCPC then
17 if (p
i
q
j
) then
18 if (not(KMasCercanos.parEnMonticulo(q
j
, p
i
))) then
19 KMasCercanos.eliminarMaximo();
20 KMasCercanos.insertarElemento(dist, p
i
, q
j
);
21 if KMasCercanos.obtenerMaximo().distancia < distanciaPodaKCPC then
22 distanciaPodaKCPC = KMasCercanos.obtenerMaximo().distancia;
23 endif
24 endif
25 else
26 KMasCercanos.insertarElemento(dist, p
i
, q
j
);
Captulo 5
166
27 endif
28 endif
29 endif
30 else
31 if KMasCercanos.estaLleno() then
32 if dist distanciaPodaKCPC then
33 KMasCercanos.eliminarMaximo();
34 KMasCercanos.insertarElemento(dist, p
i
, q
j
);
35 if KMasCercanos.obtenerMaximo().distancia < distanciaPodaKCPC then
36 distanciaPodaKCPC = KMasCercanos.obtenerMaximo().distancia;
37 endif
38 endif
39 else
40 KMasCercanos.insertarElemento(dist, p
i
, q
j
);
41 endif
42 endif
43 enddo
44 enddo
45 endif
46 endif
Evidentemente, todas las operaciones sobre el montculo mximo (KMasCercanos) que
realicen alguna modificacin del mismo, deben tambin verse reflejadas en la tabla hash
(Auto_Tabla_Hash) que tiene asociada.
Tambin debemos destacar que la extensin a los algoritmos iterativos es inmediata, bien
sea utilizando una estrategia de bsqueda de primero el mejor basada en un montculo
mnimo global o siguiendo un recorrido en anchura combinado con una funcin de seleccin
de primero el mejor sobre cada uno de los montculos que forman la lista de montculos
mnimos por niveles.

5.8 Semi-consulta de los pares ms cercanos (Semi-CPC)

Como hemos comentado anteriormente, en [HjS98] se presenta la operacin de Semi-Join
Basado en Distancias, en la que dados los dos conjuntos de objetos P y Q, se calcula para
cada objeto de P el objeto ms prximo en Q. Es decir, esta operacin es un subconjunto del
Join Basado en Distancias donde un par de objetos (p
i
, q
j
), p
i
P aparece una sola vez en el
resultado final y est ligado con el objeto ms cercano q
j
Q. Por tanto, el mtodo para
realizar esta operacin es seguir la pista de un conjunto de pares de objetos
(vectorParesObjetos) con la primera componente fija p
i
P ((p
i
, *)), cuyo par (p
i
, q
j
) es el
ms cercano a cualquier objeto q
j
Q en un momento determinado de la ejecucin del
algoritmo. Evidentemente, la cardinalidad del conjunto resultado para esta operacin ser |P|.
El esquema bsico de las estructuras de datos asociadas a esta operacin se muestra en la
Figura 5.9.
Extensiones de los algoritmos y detalles de implementacin
167

R*-tree R
P
R*-tree R
Q

Semi-CPC
vectorParesObjetos (global)
(p
0
.OBJ, q
j
.OBJ) ... ... (p
1
.OBJ, q
j
.OBJ) (p
i
.OBJ, q
j
.OBJ)
(p
|P|
.OBJ, q
j
.OBJ)

Figura 5.9 Estructuras de datos para el procesamiento de Semi-CPC.
Al igual que ocurra con la consulta del par ms cercano, la aproximacin ms intuitiva que
se nos plantea consiste en que para cada objeto en P, se ejecuta una consulta del vecino ms
prximo en Q, ordenndose de menor a mayor el array resultante de pares de objetos segn la
distancia entre ellos, una vez que se han procesado todas las consultas de manera
independiente.
En [HjS98] se presentaron seis aproximaciones para realizar dicha operacin, todas ellas
teniendo como base el algoritmo del Join Basado en Distancias (incremental e iterativo). A
estas alternativas las denominaron: Outside, Inside1, Inside2, Local, GlobalNode y GlobalAll.
Despus de una extensa comparacin de resultados, llegaron a la conclusin de que la mejor
alternativa es GlobalAll, aunque sta requiere una notable cantidad de memoria adicional por
tener todos los elementos (MBRs y objetos) de R
P
cargados en memoria durante la ejecucin
del algoritmo. Para resolver este mismo problema vamos a adaptar nuestros algoritmos a las
dos ltimas polticas, que denominamos GlobalObjetos y GlobalTodos.
GlobalObjetos. Esta primera variante consiste en almacenar en vectorParesObjetos los
MBRs u objetos que se encuentran en las hojas del R*-tree R
P
junto con el elemento de
R
Q
con mnima distancia entre ellos. El esquema de esta variante es el que se muestra en
la Figura 5.9, siendo p
i
.obj los elementos almacenados en las hojas del R*-tree R
P
.
GlobalTodos. Esta variante est fundamentada en la idea de que para cada MBR de los
nodos internos de R
P
(p
i
.MBR), se puede tener almacenada la distancia
MinMaxDist(p
i
.MBR, q
j
.MBR) ms pequea que ha sido examinada hasta el momento.
Para ello, debemos mantener un array de pares de MBRs (vectorParesMBRs), en el que
debe haber una entrada para cada MBR de los nodos internos de R
P
y tener en cada una
la mnima MinMaxDist de ese MBR de R
P
con cualquier otro MBR de R
Q
encontrado
hasta el momento. Al considerar un par de MBRs (p
i
.MBR, q
j
.MBR) para ser
procesado, debemos estar seguros de que MinMaxDist(p
i
.MBR, q
j
.MBR) es menor o
igual que la menor de las distancias MinMaxDist para p
i
.MBR almacenada hasta el
momento en la entrada correspondiente del array de pares de MBRs vectorParesMBRs.
Por ello, esta variante requiere una gran cantidad de memoria adicional, ya que R
P
est
Captulo 5
168
almacenado completamente en memoria: los objetos de las hojas de R
P
en
vectorParesObjetos y los MBRs de R
P
en vectorParesMBRs, adems de una tabla hash
(segn p
i
.OBJ y p
i
.MBR, respectivamente) asociada a cada conjunto para acceder
directamente a cualquier entrada. El esquema para esta variante es el que se muestra en
la Figura 5.10.

R*-tree R
P
R*-tree R
Q

Semi-CPC
vectorParesMBRs
(global)
(global)
vectorParesObjetos
(p
0
.OBJ, q
j
.OBJ) ... ... (p
1
.OBJ, q
j
.OBJ) (p
i
.OBJ, q
j
.OBJ)
(p
|P|
.OBJ, q
j
.OBJ)
(p
0
.MBR, q
j
.MBR) ... ... (p
1
.MBR, q
j
.MBR) (p
i
.MBR, q
j
.MBR) (p
|P|
.MBR, q
j
.MBR)

Figura 5.10 Estructuras de datos para el procesamiento de Semi-CPC utilizando la variante
GlobalTodos, donde X = nmero de MBRs en el R*-tree R
P
.
El algoritmo general para adaptar la versin recursiva de K-CPC y resolver la operacin
de Semi-CPC utilizando la variante GlobalTodos sobre dos R*-trees con la misma altura es el
que se muestra a continuacin:
Semi_Recursivo_CPC_GlobalTodos(nP, nQ: R_nodo; vectorParesMBRs: ListaParesMBRs;
vectorParesObjetos: ListaParesObjetos)
01 if nP and nQ son nodos INTERNOS then
02 actualizarVectorParesMBRs(nP, nQ, vectorParesMBRs);
03 for every entrada p
i
de nP do
04 for every entrada q
j
de nQ do
05 if MinMinDist(p
i
.MBR, q
j
.MBR) vectorParesMBR(p
i
.MBR).MinMaxDist then
06 nP = LeerNodo(p
i
.direccion);
07 nQ = LeerNodo(q
i
.direccion);
08 Semi_Recursivo_CPC_GlobalTodos(nP, nQ, vectorParesMBRs, vectorParesObjetos);
09 endif
10 enddo
11 enddo
12 else
13 for every entrada p
i
de nP do
14 for every entrada q
j
de nQ do
15 dist = MinMinDist(p
i
.MBR, q
j
.MBR);
16 if dist vectorParesObjetos(p
i
).distancia then
17 vectorParesObjetos(p
i
).distancia = dist;
18 vectorParesObjetos(p
i
).parObjetos = (p
i
, q
j
);
Extensiones de los algoritmos y detalles de implementacin
169
19 endif
20 enddo
21 enddo
22 endif
donde la funcin actualizarVectorParesMBRs viene dada por el siguiente algoritmo:
actualizarVectorParesMBRs(nP, nQ: R_nodo; vectorParesMBRs: ListaParesMBRs)
01 Crear_Lista(LISTAMnMxDIST, nP.numeroDeEntradas);
02 for every entrada p
i
de nP do
03 for every entrada q
j
de nQ do
04 if MinMaxDist(p
i
.MBR, q
j
.MBR) < LISTAMnMxDIST[i].MinMaxDist then
05 LISTAMnMxDIST[i].MinMaxDist = MinMaxDist(p
i
.MBR, q
j
.MBR);
06 LISTAMnMxDIST[i].MBR_P = p
i
.MBR;
07 LISTAMnMxDIST[i].MBR_Q = q
j
.MBR;
08 endif
09 enddo
10 enddo
11 for every entrada e
i
de LISTAMnMxDIST do
12 if (LISTAMnMxDIST[i].MinMaxDist <
vectorParesMBRs(LISTAMnMxDIST[i].MBR_P).MinMaxDist) then
13 vectorParesMBRs(LISTAMnMxDIST[i].MBR_P).MinMaxDist = LISTAMnMxDIST[i].MinMaxDist;
14 vectorParesMBRs(LISTAMnMxDIST[i].MBR_P).MBR_Q = LISTAMnMxDIST[i].MBR_Q;
15 endif
16 enddo
17 Destruir_Lista(LISTAMnMxDIST);
Al igual que ocurra con las otras extensiones, podemos adaptar fcilmente estas
modificaciones a los algoritmos iterativos, bien sea utilizando una estrategia de bsqueda de
primero el mejor basada en un montculo mnimo global o siguiendo un recorrido en anchura
combinado con una funcin de seleccin de primero el mejor sobre cada uno de los
montculos que forman la lista de montculos mnimos por niveles.
Siguiendo las directrices indicadas al comienzo de este captulo, se puede adaptar este
algoritmo (Semi_Recursivo_CPC_GlobalTodos) para realizar el tratamiento sobre R*-trees
con diferentes alturas siguiendo cualquiera de las dos tcnicas estudiadas fijar la raz o fijar
las hojas.

5.9 Conclusiones

En este captulo se han descrito las extensiones ms representativas de los algoritmos branch-
and-bound presentados anteriormente que encuentran el par ms cercano de dos conjuntos de
objetos indexados en sendos R*-trees, con el objetivo de mostrar la gran operatividad de los
mismos. Adems, junto con las descripciones de dichas extensiones se han propuesto
algoritmos, estructuras de datos adicionales y detalles de implementacin que nos permitirn
llevarlas a cabo.
Son muchas las extensiones a la consulta del par ms cercano que se podan haber
planteado, pero hemos querido destacar las ms representativas:
Captulo 5
170
1. Tratamiento sobre R*-trees con diferentes alturas, proponiendo las alternativas de fijar
la raz y fijar las hojas sobre el recorrido simultneo de ambos rboles.
2. Extensin de la consulta donde los objetos indexados no estn almacenados en las hojas
de los rboles, sino que en estos nodos terminales se encuentran los MBRs de dichos
objetos junto con punteros a los registros en otro archivo externo, donde realmente
estara guardada la representacin exacta de los mismos.
3. Generalizacin de la consulta del par ms cercano para obtener los K pares ms
cercanos desde un punto de vista algortmico. Para este caso proponemos nuevas
heursticas de poda y las estructuras de datos necesarias para poder extender los
algoritmos branch-and-bound diseados en el captulo anterior.
4. Obtener todos los pares o solamente los K ms cercanos dentro de un rango de distancia
determinado dado a priori es una extensin interesante y de gran utilidad, ya que
combina nuestra consulta en cuestin con la delimitacin del resultado dentro de un
rango en el dominio solucin (consulta en rango).
5. La consulta del par ms lejano y de los K pares ms lejanos es otro caso de estudio a
considerar. Los algoritmos branch-and-bound que dan respuesta a esta consulta estn
basados en la mtrica MaxMaxDist y utiliza heursticas de poda similares a las de los
pares ms cercanos.
6. La Auto-consulta de los pares ms cercanos consiste en combinar un conjunto de
objetos de entrada indexado en su correspondiente R*-tree consigo mismo para
determinar cules son los objetos ms cercanos entre s. Como tal extensin, tiene como
base los algoritmos branch-and-bound previamente estudiados, adems de estructuras de
datos adicionales y reglas de poda particulares que nos permiten obtener el resultado
deseado.
7. Por ltimo, la Semi-consulta de los pares ms cercanos, encuentra, para cada objeto
indexado en un R*-tree, el objeto ms cercano indexado en el otro rbol. Los algoritmos
branch-and-bound que la llevan a cabo son similares a los diseados en el captulo
anterior salvo que hay que mantener informacin adicional del primer R*-tree para que
la poda sea ms efectiva durante el recorrido sincronizado de ambos rboles. Para esta
extensin proponemos dos alternativas denominadas GlobalObjetos y GlobalTodos.
La evaluacin de las extensiones previamente planteadas requiere tambin un importante
trabajo de anlisis e implementacin de las mismas, dentro de un marco experimental, para
establecer su correcto funcionamiento. Toda esta labor de anlisis abarca desde la definicin
de bateras de pruebas hasta el posterior tratamiento de resultados, tareas que se llevarn a
cabo en el siguiente captulo.


171


Captulo 6


RESULTADOS EXPERIMENTALES Y
APLICACIN



6.1 Introduccin

Un Sistema de Bases de Datos Espacial (SBDE) almacena datos de naturaleza espacial (por
ejemplo puntos, lneas, regiones, volmenes, superficies, figuras geomtricas, etc.)
procedentes de fenmenos que se producen tanto sobre la superficie de la Tierra como en su
interior [LaT96]. Como hemos comentado en el captulo 3, los SGBDEs deben soportar tipos
de datos espaciales en su implementacin, y suministrar mtodos de indexacin espacial y
algoritmos eficientes para el procesamiento de consultas [Gt94]. Algunas de estas consultas
son muy sencillas de procesar, como por ejemplo, localizar un punto en un conjunto de
puntos. Existen otras consultas mas complicadas, como por ejemplo, encontrar el vecino ms
prximo, consultas sobre un rango determinado, comprobar si un determinado objeto se
encuentra dentro de un rango establecido, realizar operaciones sobre mapas (unin, diferencia,
interseccin de mapas), etc. Adems, el R-tree ha sido adoptado como mtodo de acceso
espacial en sistemas comerciales como Oracle [Ora01] o Informix [Bro01].
El procesamiento eficiente de algunas consultas espaciales ya ha sido investigado en
profundidad, como por ejemplo, consultas del vecino ms prximo, bsquedas por similitud,
procesamiento de joins espaciales, etc. Sin embargo, el procesamiento eficiente de otras
muchas consultas importantes no ha atrado a muchos investigadores hasta el momento. Un
claro ejemplo es el caso de la consulta de los pares ms cercanos sobre conjuntos de datos
espaciales, de gran utilidad en SBDEs, como hemos podido comprobar en el captulo 3 de esta
tesis.
En el presente captulo vamos a realizar un extenso anlisis experimental con datos
espaciales (puntos 2-dimensionales) sobre los algoritmos presentados en captulos anteriores
Captulo 6
172
para la consulta del par ms cercano y sus extensiones. En primer lugar, llevamos a cabo un
conjunto de experimentos para las diferentes versiones de los algoritmos branch-and-bound
CPC y K-CPC, considerndose los siguientes parmetros a evaluar: nmero de accesos a
disco, tiempo de respuesta, mximo tamao del montculo y el nmero de inserciones en l
para los algoritmos iterativos. A continuacin, se evalan las dos tcnicas propuestas para el
tratamiento de R*-trees con diferentes alturas. Despus, se estudia el efecto del porcentaje de
solape entre las reas que cubren los conjuntos de datos que intervienen en la consulta, ya que
es un parmetro a tener en cuenta en el procesamiento de los algoritmos que dan respuesta a
este tipo de consulta. Otro aspecto a tener muy en cuenta es el efecto de incluir un buffer de
pginas junto con una poltica de reemplazo LRU (Least Recently Used) para la consulta en
cuestin, estando los dos conjuntos de objetos espaciales indexados en sendos R*-trees. En el
siguiente apartado comparamos nuestros algoritmos branch-and-bound no incrementales
(recursivos e iterativos) para K-CPC con los incrementales, obteniendo resultados realmente
interesantes, sobre todo desde el punto de vista del tiempo de respuesta requerido para
completar la consulta. Tambin se estudian, desde el punto de vista experimental, dos de las
extensiones ms interesantes de la consulta de los pares ms cercanos, como son las que
denominamos Auto-CPC y Semi-CPC. Por ltimo, se presentan las conclusiones de este
captulo relacionado con la experimentacin de nuestros algoritmos sobre datos (puntos) de
naturaleza espacial.

6.2 Resultados experimentales para CPC y K-CPC

En esta seccin mostramos un amplio estudio experimental tratando de medir y evaluar la
eficiencia de los algoritmos branch-and-bound recursivos e iterativos descritos en captulos
anteriores para obtener el par ms cercano (CPC) y su extensin para calcular los K pares ms
cercanos (K-CPC).

6.2.1 Objetivos

Sabemos que la eficiencia de un algoritmo para el procesamiento de consultas puede
determinarse en base a tres criterios principales:
1. Nmero de accesos a disco. Este parmetro nos indica el nmero de operaciones de E/S
necesarias para realizar la consulta.
2. Tiempo de respuesta. Indica el tiempo total requerido para llevar a cabo la consulta.
Este tiempo depende de varios factores como, por ejemplo, el nmero de operaciones de
insercin y borrado de pares en las estructuras de datos adicionales para realizar la
consulta. Otro parmetro que afecta a esta mtrica sera el nmero de clculos de
distancias entre pares de objetos o MBRs que requiere la consulta.
Resultados experimentales y aplicacin
173
3. Utilizacin de recursos adicionales como, por ejemplo, reas de memoria principal para
almacenar montculos. Debido a que las operaciones de insercin y eliminacin de pares
de un montculo estn relacionadas con el nmero de objetos que actualmente se
encuentran almacenados en l, tambin se ha tenido en cuenta el nmero de inserciones
de pares en dicha estructura de datos.
Los objetivos de esta fase experimental son principalmente:
1. Optimizar el nmero de accesos a disco (fundamentalmente mediante la utilizacin de -
buffers).
2. Reducir el tiempo global de respuesta requerido por este tipo de consulta.
3. Minimizar los recursos necesarios para realizar la consulta (tamao mximo del
montculo principal para los algoritmos iterativos).

6.2.2 Definicin de los experimentos

Hemos escogido al R*-tree [BKS
+
90] como mtodo de acceso espacial para los experimentos
en lugar del R-tree original [Gut84], ya que el primero utiliza unas tcnicas ms sofisticadas
para la insercin de objetos y divisin de nodos, tratando de reducir al mximo el solape entre
MBRs en nodos ubicados en el mismo nivel del rbol (cuanto menor es el solape entre MBRs
en el nodo de un rbol, menor es el nmero de caminos que hay que recorrer para encontrar
un objeto determinado), generando una estructura ms compacta. En [BKS
+
90] se demuestra
que utilizando el R*-tree en determinadas consultas espaciales se obtiene una mejora del
rendimiento por encima del 50% que si se utiliza el R-tree original. El algoritmo CPC y su
extensin para K-CPC puede aplicarse tanto para R*-trees como para R-trees ya que a nivel
de estructura de datos no hay apenas diferencias.
Los experimentos se han realizado con puntos pertenecientes a E
(2)
, aunque la extensin
para dimensiones mayores es sencilla para esta estructura de ndice arbrea (R*-tree). La
naturaleza y cardinalidad de los conjuntos de datos (puntos) con los que se ha experimentado
ha sido muy variada. Se han realizado todas las posibles combinaciones de dos R*-trees
(alturas = 4 y 5) indexando conjuntos de puntos reales (ncleos de poblacin de California)
[SFG
+
93], conjuntos de puntos reales movidos aleatoriamente de posicin (Figura 6.1), y
conjuntos de puntos artificiales generados aleatoriamente y siguiendo una distribucin
uniforme.



Captulo 6
174

Figura 6.1 Figura con ejemplos de los conjuntos de puntos (California), reales y reales
movidos aleatoriamente.
Debemos destacar que todos los experimentos se han ejecutado en un Pentium III (450
MHz) sobre Linux Red Hat 6.1 y todas las estructuras de datos y algoritmos se han
implementado en C++ utilizando el compilador C/C++ de GNU, gcc (-O3 como parmetro
optimizador). El tamao de la pgina (nodo del R*-tree) para los experimentos es de 1 Kbyte
cuya capacidad del nodo equivale a M = 28 y m = 9 (m = 0.35*M1, segn se indica en
[BKS
+
90] como valor ptimo), utilizando precisin double para cada una de las coordenadas
de los MBRs en los nodos de los R*-trees.
El objetivo principal que perseguimos con la realizacin de estos experimentos es llevar a
cabo un primer estudio del comportamiento de los algoritmos para CPC y K-CPC. Para ello,
consideramos importante tener en cuenta los siguientes parmetros en la definicin de
nuestros experimentos:
1. Cardinalidad del resultado. CPC y K-CPC (K = 1, 10, 100, 1000, 10000, 100000 y en
algunos casos 1000000). Estudiando el efecto que tiene incluir MinMaxDist para CPC y
MaxMaxDist para K-CPC.
2. Diferentes cardinalidades y naturaleza de los conjuntos de datos (puntos) espaciales
indexados por los R*-trees. Datos reales, reales movidos al azar, y generados
aleatoriamente con 62556 puntos 2D. Conjuntos de puntos generados aleatoriamente y
siguiendo una distribucin uniforme con diferentes cardinalidades (10000, 30000,
60000 y 120000).
3. Tratamiento de pares cuyo valor para MinMinDist puede ser el mismo. Las tcnicas para
el tratamiento de empates se pueden aplicar tanto a los algoritmos recursivos (que
establecen una ordenacin local segn MinMinDist de pares de MBRs procedentes de la
combinacin de dos nodos internos) como a los iterativos (ordenacin global sobre el
montculo mnimo principal de pares de MBRs).
4. Mximo nmero de pares de MBRs almacenados en el montculo mnimo principal
utilizado para los algoritmos iterativos. ste es un parmetro importante, porque
operaciones de insercin (O(log N)) y borrado del mnimo (O(log N)) sobre l,
dependen del nmero de elementos almacenados en el montculo.
Resultados experimentales y aplicacin
175
Para este primer estudio hemos considerado fijar una serie de parmetros (que
posteriormente se analizarn con mayor detalle):
1. Para R*-trees con diferentes alturas, utilizamos la tcnica Fijar las Hojas.
2. Las reas que cubren los conjuntos de datos (puntos) que intervienen en la consulta se
encuentran totalmente solapadas (100%).
3. No se considera el efecto de buffers adicionales.
La definicin de estos experimentos en base a los anteriores parmetros nos permite
evaluar y comparar en trminos de eficiencia (minimizar el nmero de operaciones de E/S, el
tiempo de respuesta y los recursos adicionales requeridos) nuestros algoritmos branch-and-
bound que obtienen el par ms cercano y sus extensiones ms representativas.
Tambin debemos indicar que se han utilizado las mismas abreviaciones de [CMT
+
00a,
CMT
+
00b] para los algoritmos branch-and-bound. stas son las siguientes: (1) recursivo
siguiendo una estrategia de bsqueda en profundidad (RECU), (2) iterativo utilizando un
montculo mnimo global con una estrategia de bsqueda basada en una funcin de seleccin
de primero el mejor (HEAP) y (3) iterativo basado en un recorrido en anchura utilizando una
lista de montculos mnimos siguiendo en cada uno de ellos una estrategia de bsqueda con
una funcin de seleccin de primero el mejor (BFT). Adems, para las diferentes alternativas
que se pueden aplicar a los anteriores algoritmos tenemos las siguientes abreviaciones: (1) no
tener en cuenta ningn criterio de poda (BRU), (2) considerar MinMinDist como mtrica de
poda para los algoritmos branch-and-bound (EXH), (3) considerar MinMaxDist y MinMinDist
en CPC y, MaxMaxDist y MinMinDist para K-CPC (SIM), (4) ordenar en base a MinMinDist
todos los posibles pares de MBRs procedentes de la combinacin de dos nodos internos (STD
si se utiliza una lista local y, STM si se utiliza un montculo mnimo local), y (5) si utilizamos
la tcnica de Barrido del Plano (PS).

6.2.3 Presentacin y anlisis de los resultados

Evaluacin del nmero de accesos a disco
La Tabla 6.1 muestra los resultados (nmero de accesos a disco) de aplicar CPC tanto para las
versiones recursivas como para las iterativas. Para ello hemos utilizado los siguientes
conjuntos de datos (puntos) con las mismas cardinalidades (62556): reales y reales movidos
aleatoriamente. De esta tabla podemos obtener varias conclusiones:
1. El hecho de aplicar un algoritmo branch-and-bound recursivo o iterativo sobre un
recorrido exhaustivo en los dos ndices (BRU) para encontrar el par ms cercano,
supone un ahorro de casi 900 veces el nmero de accesos a disco. El algoritmo que
aplica un recorrido en profundidad en un R*-tree combinado con una consulta del
vecino ms prximo (R+CVP) tampoco supone ninguna mejora sobre los algoritmos
branch-and-bound (casi 10 veces ms de accesos a disco).
Captulo 6
176
2. Las variantes de los algoritmos iterativos (HEAP y BFT) no se ven afectadas,
obteniendo en todas el mismo nmero de accesos a disco, ya que el efecto de aplicar las
diferentes alternativas que combinan los MBRs procedentes de dos nodos internos es
despreciable respecto a la gestin de un montculo (global o por niveles) de pares de
MBRs organizado segn su MinMinDist.
3. El algoritmo que obtiene sensiblemente mejores resultados es HEAP. BFT es
ligeramente peor que las diferentes versiones del algoritmo recursivo. El hecho de que
HEAP sea el mejor algoritmo es porque aplica una funcin de seleccin de primero el
mejor sobre un montculo mnimo de pares de MBRs gestionado a nivel global,
minimizando el nmero de pares de MBRs a considerar durante la ejecucin del
algoritmo. BFT, proporciona los peores resultados, ya que sigue una estrategia de
bsqueda en anchura (aunque para cada nivel los pares de MBRs se organicen en un
montculo mnimo), debindose procesar todos los pares de MBRs de un nivel antes de
pasar al siguiente.
4. De los algoritmos recursivos, STD y STM son sensiblemente mejores que el resto. La
razn es que estas variantes ordenan las distancias (MinMinDist) de los pares de MBRs
que se generan en los nodos internos a nivel local, haciendo posible que se encuentre el
par ms cercano con mayor rapidez.
5. De los algoritmos iterativos, HEAP nos proporciona siempre mejores resultados que
BFT, debido a la forma de organizar los pares de MBRs candidatos a procesar segn un
algoritmo iterativo (HEAP utiliza un montculo mnimo global, mientras que BFT
emplea una lista de montculos mnimos organizada por niveles).
6. El efecto de aplicar o no MinMaxDist se puede apreciar en los algoritmos recursivos que
no ordenan los MBRs en base a su MinMinDist (EXH y SIM) donde slo aparece una
mejora de 22 accesos a disco, lo que supone un ahorro del 0.05%. De lo que deducimos,
que aplicar esta mtrica no afecta mucho en la reduccin del nmero de accesos a disco,
fenmeno que se aprecia claramente cuando aplicamos MinMinDist (mtrica principal
de poda) en la variante EXH.

RECU HEAP BFT
R+CVP 358721
BRU 33812010
EXH 37868 37830
SIM 37846 37830 37966
STD 37838 37830 37966
STM 37838 37830 37966
PS 37880 37830 37966
Tabla 6.1 Nmero de accesos a disco para CPC.
Sobre los mismos conjuntos de datos (puntos) indexados en sendos R*-trees aplicamos los
algoritmos RECU_EXH, RECU_STD, HEAP_SIM y BFT_SIM para K-CPC (Tabla 6.2 y
Figura 6.2, hasta K = 100000) y obtenemos conclusiones similares a las anteriores (para CPC)
tales como:
Resultados experimentales y aplicacin
177
1. Las variantes de los algoritmos iterativos (HEAP y BFT) no se ven afectadas entre ellas
para un determinado valor de K.
2. HEAP_SIM es siempre la mejor alternativa.
3. Para K = 1, BFT_SIM es el peor, y para K 100, todas las variantes del algoritmo
recursivo nos proporcionan los peores resultados.
4. RECU_STD es la mejor variante de los algoritmos recursivos.
5. Conforme aumenta el valor de K la diferencia en nmero de accesos a disco entre los
algoritmos recursivos e iterativos se ve incrementada.
6. La diferencia que existe entre HEAP_SIM y BFT_SIM es debido a que el primero
organiza el montculo principal de forma global, minimizando el nmero de pares de
MBRs a considerar y consiguiendo los mejores candidatos segn MinMinDist ms
rpidamente, mientras que el segundo lo hace por niveles (local a cada nivel) y sigue un
recorrido en anchura.

1 10 100 1000 10000 100000 1000000
RECU_EXH 37868 38046 38558 40230 45926 66820 157722
RECU_STD 37838 38018 38494 40018 45260 63694 135632
HEAP_SIM 37830 37906 38194 38970 41782 50546 82798
BFT_SIM 38456 38532 38864 39782 42844 52066 85308
Tabla 6.2 Nmero de accesos a disco para K-CPC.
30000
38000
46000
54000
62000
70000
1 10 100 1000 10000 100000
Nmero de Pares
A
c
c
e
s
o
s

a

D
i
s
c
o
RECU_EXH RECU_STD HEAP_SIM BFT_SIM

Figura 6.2 K-CPC para algoritmos recursivos (RECU_EXH y RECU_STD) e iterativos
(HEAP_SIM y BFT_SIM).
Debemos destacar tambin que el algoritmo recursivo que no utiliza ningn criterio de
poda (BRU) requiere 33812010 accesos a disco para cualquier valor de K. Y para el algoritmo
que realiza un recorrido en profundidad en el primer R*-tree, ejecutando una consulta de los
K vecinos ms prximos en el segundo, y seleccionando los K pares con menor distancia
Captulo 6
178
entre ellos, obtenemos los siguientes resultados para el nmero de accesos a disco segn el
valor de K: (<1, 360519>, <10, 545046>, <100, 1580073>, <1000, 8652381>, <10000,
59885634>, <100000, 272411237>). Debido a su elevado nmero de accesos a disco, estos
dos algoritmos han sido descartados para futuros experimentos.
En la Figura 6.3 se ilustra el coste relativo en tanto por ciento de K-CPC respecto al
nmero de accesos a disco de los algoritmos RECU_STD, HEAP_SIM y BFT_SIM, tomando
como referencia RECU_EXH (100%). En ella se puede apreciar la ganancia considerable que
tienen los algoritmos iterativos conforme se incrementa el valor de K, llegando a ser prxima
al 25% y 50% para HEAP_SIM cuando K = 100000 y K = 1000000, respectivamente.
50%
62%
74%
86%
98%
110%
1 10 100 1000 10000 100000 1000000
Nmero de Pares
C
o
s
t
e

R
e
l
a
t
i
v
o
RECU_STD HEAP_SIM BFT_SIM

Figura 6.3 Coste relativo de RECU_STD, HEAP_SIM y BFT_SIM respecto a RECU_EXH.
Tambin se ha estudiado el efecto de aplicar MaxMaxDist para K-CPC (para BFT siempre
se utiliza), observndose que para el nmero de accesos a disco no tiene ninguna
trascendencia en los algoritmos iterativos, aunque s para el nmero de inserciones en el
montculo principal y para el tamao mximo en nmero de pares, como se puede observar en
las Tablas 6.3 y 6.4 para puntos reales y reales movidos aleatoriamente. Aplicar MaxMaxDist
en el algoritmo recursivo (la nica alternativa que se ve afectada es SIM) produce un ahorro
casi despreciable en el nmero de accesos a disco del (0.06%, 0.06%, 0.06%, 0.21%, 0.46%,
0.53%) para K = (1, 10,100, 1000, 10000, 100000), respectivamente. Adems, hemos
observado que BFT para CPC, en todas sus alternativas, el uso de MinMaxDist tiene un mejor
comportamiento que aplicar MaxMaxDist para K = 1 en lo que respecta al nmero de accesos
a disco, producindose un ahorro del 1.25%.





Resultados experimentales y aplicacin
179
1 10 100 1000 10000 100000
EXH 6791 6843 8357 9241 18408 49524
SIM 2452 6791 2561 6843 3322 8357 5265 9241 9861 18408 34518 49524
63.89% 62.57% 60.24% 43.02% 46.43% 30.30%
STD 2093 7403 2088 8029 2672 8448 3617 9579 9914 20343 39240 50361
71.72% 73.99% 68.37% 62.24% 51.26% 22.08%
STM 2319 10197 2584 10300 2657 10482 5084 11234 12153 17234 34653 55327
77.25% 74.91% 74.65% 54.74% 30.66% 37.36%
PS 3012 8254 3207 8515 3086 9084 5986 20184 9714 35209 37519 61075
63.50% 62.37% 66.02% 70.34% 72.41% 38.56%
Tabla 6.3 Tamao mximo del montculo principal para K-CPC (HEAP), considerando y sin
considerar MaxMaxDist.

1 10 100 1000 10000 100000
EXH 23738 23910 24500 26268 35698 68246
SIM 19880 23738 19963 23910 20500 24500 22602 26268 27678 35698 52164 68246
16.25% 16.51% 16.32% 13.95% 22.46% 23.56%
STD 19698 23912 19820 24137 20222 24914 21330 27039 27138 38185 57323 56454
17.62% 17.88% 18.83% 21.11% 28.93% 16.26%
STM 20225 27738 20319 27849 20343 28088 22373 28980 30266 34089 51961 73443
26.97% 26.78% 27.57% 22.79% 11.12% 29.24%
PS 20141 24900 20282 25603 20939 26362 23479 37975 27740 52283 56284 79362
19.11% 20.78% 20.57% 38.17% 46.94% 29.07%
Tabla 6.4 Nmero de inserciones en el montculo principal para K-CPC (HEAP),
considerando y sin considerar MaxMaxDist.
Las Tablas 6.3 y 6.4 muestran el efecto de aplicar o no la mtrica MaxMaxDist sobre las
variantes de los algoritmos que utilizan un montculo mnimo principal para evitar la
recursividad (HEAP), respecto del tamao mximo del montculo (Tabla 6.3) y del nmero de
inserciones (Tabla 6.4) de/en dicha estructura de datos. De forma general, podemos decir que
incluir dicha mtrica favorece considerablemente a estos dos parmetros (a costa de incluir un
montculo adicional MMMD, cuyo tamao mximo en pares fue en todos los casos <2, 2, 4,
22, 206, 2042, 20410> segn los valores de K), proporcionando la alternativa STD los
mejores resultados, sensiblemente superiores a SIM y STM. Segn los porcentajes de las
Tablas 6.3 y 6.4, cuando K 100, el incluir o no dicha mtrica hace que STM sea la mejor
alternativa para ambos parmetros, mientras que si K 1000, PS nos proporciona los
porcentajes ms altos. Tambin debemos indicar que estos mismos parmetros aplicados
sobre las variantes en el algoritmo BFT, donde el montculo principal est organizado por
niveles, mostr una tendencia similar en los resultados aunque con valores ms altos (sobre
un 67.42% superior para el tamao mximo del montculo y del 52.47% para el nmero de
inserciones cuando K = 100000). Otro aspecto que se debe considerar es la relacin existente
entre el tamao mximo del montculo y el nmero de inserciones en l cuando aplicamos
MaxMaxDist. Evidentemente, conforme disminuye el tamao mximo del montculo, el
nmero de inserciones en l es tambin menor, propiedad que se verifica para todos los casos,
ya que el nmero de nodos internos que se combinan durante la ejecucin del algoritmo y que
se almacenan en el montculo principal ser tambin menor.

Captulo 6
180
Demostracin del comportamiento de MinMaxDist (CPC) y MaxMaxDist (K-CPC)
respecto al nmero de accesos a disco
En el captulo 3 hemos definido las distancias MinMinDist, MinMaxDist y MaxMaxDist, las
cuales se utilizan en heursticas de poda (MinMinDist) y de actualizacin de
parMasCercano.distancia para CPC (MinMaxDist) y distanciaPodaKCPC (MaxMaxDist)
sobre algoritmos branch-and-bound recursivos e iterativos. Recordemos que las dos
heursticas para CPC basadas en MinMinDist y MinMaxDist son las siguientes:
1. Si parMasCercano.distancia es la distancia Eucldea del par ms cercano encontrado
hasta el momento (temporal), entonces todos los pares de MBRs (R
Pi
, R
Qj
) tal que R
Pi

R
P
y R
Qj
R
Q
, con distancia MinMinDist(R
Pi
, R
Qj
) estrictamente mayor que
parMasCercano.distancia pueden descartarse, ya que estos pares de MBRs no incluirn
otro par de objetos con distancia menor que parMasCercano.distancia.
2. Si un par de MBRs (R
Pi
, R
Qj
) tal que R
Pi
R
P
y R
Qj
R
Q
tiene un valor de
MinMinDist(R
Pi
, R
Qj
) mayor que MinMaxDist(R
Pi
, R
Qj
) de otro par de MBRs (R
Pi
,
R
Qj
) tal que R
Pi
R
P
y R
Qj
R
Q
, entonces el par (R
Pi
, R
Qj
) puede descartarse, porque
no puede contener al par ms cercano. Adems, si parMasCercano.distancia es la
distancia del par ms cercano encontrado hasta el momento podemos actualizarla de la
siguiente forma: Si MinMaxDist(R
Pi
, R
Qj
) < parMasCercano.distancia, entonces
parMasCercano.distancia = MinMaxDist(R
Pi
, R
Qj
).
Los resultados experimentales mostrados en este captulo nos indican que el uso de las
heursticas basadas en MinMaxDist para CPC y MaxMaxDist para K-CPC no supone ahorro
alguno en el nmero de accesos a disco. Por tanto, vamos a demostrar este comportamiento
para la consulta del par ms cercano utilizando el algoritmo recursivo siguiendo un esquema
de recorrido en profundidad y ordenando todos los posibles pares de MBRs procedentes de
nodos internos segn MinMinDist
(CPC_Recursivo_MINMAXDIST_MINMINDIST_Ordenado), de la misma forma que se
presenta en [ChF98] para el algoritmo recursivo que encuentra el vecino ms prximo
propuesto en [RKV95].
La demostracin del comportamiento del algoritmo se podra haber hecho de dos formas:
(1) en base al funcionamiento propio del algoritmo sobre los dos R*-trees y (2) estudiando el
rbol de solucin generado. Hemos optado por la primera, ya que resulta ms sencilla e
ilustrativa de seguir. Para ello, empezaremos con una serie de lemas que muestran
propiedades de las mtricas aplicadas al algoritmo en cuestin, y concluiremos con el teorema
que demuestra su comportamiento.
Lema 6.1.
Dados dos MBRs R
1
y R
2
de dos R*-trees en E
(k)
, envolviendo a los conjuntos de objetos O
1
=
{o
1i
, 1iN
1
} y O
2
= {o
2j
, 1jN
2
}, respectivamente. Si (o
11
, o
21
) es el par ms cercano,
entonces
MinMinDist(R
1
, R
2
) ||(o
11
, o
21
)|| MinMaxDist(R
1
, R
2
)
Demostracin:
Resultados experimentales y aplicacin
181
Por definicin MinMinDist(R
1
, R
2
) es la mnima distancia entre los dos MBRs R
1
y R
2
. Por la
propiedad de las caras de un MBR en un R*-tree y si (o
11
, o
21
) es el par de objetos ms
cercano de los que se pueden formar estando cubiertos por R
1
y R
2
, entonces por el teorema
3.5, se verifica que ||(o
11
, o
21
)|| MinMaxDist(R
1
, R
2
). Por tanto, MinMinDist(R
1
, R
2
) y
MinMaxDist(R
1
, R
2
) sirven de cota inferior y superior para la distancia del par ms cercano,
respectivamente.
Lema 6.2.
Si el par de MBRs (R
1
, R
2
) es un ancestro del par de MBRs (R
1
, R
2
) en dos R*-trees,
entonces
MinMinDist(R
1
, R
2
) MinMinDist(R
1
, R
2
)
Demostracin:
La demostracin es consecuencia inmediata de la definicin de MinMinDist(R
1
, R
2
) y de la
propiedad de las caras de un MBR en un R*-tree.
Lema 6.3.
Si hay dos pares de MBRs (R
1
, R
2
) y (R
1
, R
2
) verificando la condicin MinMinDist(R
1
, R
2
)
MinMinDist(R
1
, R
2
), entonces MinMaxDist(R
1
, R
2
) nunca ser estrictamente menor que
MinMinDist(R
1
, R
2
).
Demostracin:
Por el Lema 6.1, MinMinDist(R
1
, R
2
) MinMaxDist(R
1
, R
2
). Suponiendo que se verifica la
precondicin MinMinDist(R
1
, R
2
) MinMinDist(R
1
, R
2
), tenemos que MinMinDist(R
1
, R
2
)
MinMinDist(R
1
, R
2
) MinMaxDist(R
1
, R
2
), entonces MinMaxDist(R
1
, R
2
) nunca ser
estrictamente menor que MinMinDist(R
1
, R
2
).
Lema 6.4.
Dado el algoritmo branch-and-bound
CPC_Recursivo_MINMAXDIST_MINMINDIST_Ordenado, si un par de MBRs (R
1
, R
2
)
est antes que el par (R
1
, R
2
) dentro de la misma lista de pares de MBRs ordenados segn
MinMinDist que combina dos nodos internos de dos R*-trees a nivel local y MinMaxDist(R
1
,
R
2
) < MinMinDist(R
1
, R
2
), entonces la distancia del par ms cercano temporal encontrado
hasta el momento, parMasCercano.distancia, es menor o igual que MinMaxDist(R
1
, R
2
)
(parMasCercano.distancia MinMaxDist(R
1
, R
2
)) justo antes de que el par de MBRs (R
1
,
R
2
) se procese o se pode.
Demostracin:
Sea S el conjunto de pares de MBRs que estn inmediatamente despus del par (R
1
, R
2
) y
justo antes de (R
1
, R
2
) en la misma lista que combina todos los pares de MBRs ordenados
segn MinMinDist procedentes de dos nodos internos. Sea (o
11
, o
21
) el par de objetos ms
cercano encontrado justo antes de procesar (R
1
, R
2
). Recordemos que el par (R
1
, R
2
) se poda,
cuando ste se descarta normalmente o cuando se poda uno de sus pares de MBRs ancestros.
Para demostrar este lema tenemos que considerar los dos siguientes casos:
Caso 1. El par de objetos (o
11
, o
21
) se encuentra cubierto por S. En este caso, (o
11
, o
21
) ha sido
considerado como par candidato temporal (parMasCercano.distancia ||(o
11
, o
21
)||) a ser el
Captulo 6
182
ms cercano antes de procesar o podar (R
1
, R
2
) debido a que el algoritmo sigue un recorrido
en profundidad, entonces sabemos que su distancia es menor o igual que MinMaxDist(R
1
,
R
2
), es decir, ||(o
11
, o
21
)|| MinMaxDist(R
1
, R
2
). Por tanto, parMasCercano.distancia
MinMaxDist(R
1
, R
2
).
Caso 2. El par de objetos (o
11
, o
21
) no se encuentra cubierto por S (se encuentra cubierto por
(R
1
, R
2
) aunque no ha sido podado por l). Por el Lema 6.1 y la precondicin de este lema,
se verifica que ||(o
11
, o
21
)|| MinMaxDist(R
1
, R
2
) < MinMinDist(R
1
, R
2
). Adems, por el
Lema 6.2, tenemos que todos los pares de MBRs ancestros de (o
11
, o
21
) tienen un valor de
MinMinDist menor o igual que MinMinDist(R
1
, R
2
). Como (o
11
, o
21
) no se encuentra cubierto
por S, entonces un par de MBRs ancestro de (R
1
, R
2
), sea ste (R
1
, R
2
), debe haber sido
descartado por la heurstica 2 (actualizar parMasCercano.distancia utilizando MinMaxDist).
Es decir, el par de MBRs (R
1
, R
2
) se descarta porque MinMinDist(R
1
, R
2
) >
parMasCercano.distancia. Por tanto, parMasCercano.distancia < MinMinDist(R
1
, R
2
)
MinMaxDist(R
1
, R
2
), entonces parMasCercano.distancia MinMaxDist(R
1
, R
2
).
Lema 6.5.
Dado el algoritmo branch-and-bound
CPC_Recursivo_MINMAXDIST_MINMINDIST_Ordenado, si un par de MBRs se poda
por la heurstica 1 (MinMinDist) utilizando previamente la heurstica 2 (MinMaxDist),
entonces este par tambin se podar por la heurstica 1 (MinMinDist) sin utilizar la
heurstica 2 (MinMaxDist), una vez que parMasCercano.distancia ha sido actualizado a nivel
de hojas.
Demostracin:
En este lema lo que pretendemos demostrar es lo siguiente:
poda con heurstica 1 utilizando la heurstica 2 poda con heurstica 1 sin utilizar la
heurstica 2
La heurstica 2 dice que, si MinMinDist(R
1
, R
2
) > MinMaxDist(R
1
, R
2
), entonces el par de
MBRs (R
1
, R
2
) se descartar. Sin perder generalidad, supongamos que tenemos dos pares de
MBRs cualquiera (R
1
, R
2
) y (R
1
, R
2
) en la misma lista que combina todos los pares de
MBRs ordenados segn MinMinDist procedentes de dos nodos internos tal que, (R
1
, R
2
) se
descarta debido a (R
1
, R
2
) por la heurstica 2, por tanto MinMaxDist(R
1
, R
2
) <
MinMinDist(R
1
, R
2
). Para demostrar la consecuencia de nuestra implicacin debemos
considerar dos casos.
Caso 1. MinMinDist(R
1
, R
2
) MinMinDist(R
1
, R
2
), estando el par (R
1
, R
2
) antes que (R
1
,
R
2
) en la lista local de pares de MBRs. Segn el Lema 6.1, para (R
1
, R
2
) y (R
1
, R
2
) tenemos
las dos siguientes inecuaciones: MinMinDist(R
1
, R
2
) MinMaxDist(R
1
, R
2
) y MinMinDist(R
1
,
R
2
) MinMaxDist(R
1
, R
2
).
Por el Lema 6.3, sabemos que si dos pares de MBRs (R
1
, R
2
) y (R
1
, R
2
) verificando la
condicin MinMinDist(R
1
, R
2
) MinMinDist(R
1
, R
2
), entonces MinMaxDist(R
1
, R
2
) nunca
ser estrictamente menor que MinMinDist(R
1
, R
2
). Por tanto, es imposible que
MinMaxDist(R
1
, R
2
) < MinMinDist(R
1
, R
2
), y con ello es imposible que el par de MBRs (R
1
,
R
2
) sea podado por la heurstica 2, podndose slo con la heurstica 1.
Resultados experimentales y aplicacin
183
Caso 2. MinMinDist(R
1
, R
2
) > MinMinDist(R
1
, R
2
), estando el par (R
1
, R
2
) antes que (R
1
,
R
2
) en la lista de combinacin de pares de MBRs (no podra estar (R
1
, R
2
) antes que (R
1
, R
2
)
puesto que la lista se ordena crecientemente en base a MinMinDist).
Sea parMasCercano.distancia la distancia del par ms cercano temporal encontrado justo
antes de que el par (R
1
, R
2
) sea podado o procesado. Por el Lema 6.4,
parMasCercano.distancia MinMaxDist(R
1
, R
2
) y como MinMaxDist(R
1
, R
2
) <
MinMinDist(R
1
, R
2
) se satisface como precondicin (heurstica 2), obtenemos que
parMasCercano.distancia < MinMinDist(R
1
, R
2
), que es la condicin de la heurstica 1, y por
tanto, el MBR (R
1
, R
2
) ser descartado slo por dicha heurstica.
De este lema podemos concluir que todos los pares que se podan por la heurstica 1
utilizando la heurstica 2, son los mismos que se podan por la heurstica 1 sin utilizar la
heurstica 2, una vez que parMasCercano.distancia ha sido actualizado a nivel de hojas, en el
algoritmo CPC_Recursivo_MINMAXDIST_MINMINDIST_Ordenado.
Lema 6.6.
Dado el algoritmo branch-and-bound
CPC_Recursivo_MINMAXDIST_MINMINDIST_Ordenado, si un par de MBRs se poda
por la heurstica 1 (MinMinDist) sin utilizar previamente la heurstica 2 (MinMaxDist),
entonces este par tambin se podar por la heurstica 1 (MinMinDist) utilizando la heurstica
2 (MinMaxDist), una vez que parMasCercano.distancia ha sido actualizado a nivel de hojas.
Demostracin:
En este lema lo que pretendemos demostrar es lo siguiente:
poda con heurstica 1 sin utilizar la heurstica 2 poda con heurstica 1 utilizando la
heurstica 2
Supongamos que durante la ejecucin del algoritmo hay un par de MBR (R
1
, R
2
) que verifica
que MinMinDist(R
1
, R
2
) > parMasCercano.distancia, entonces el par (R
1
, R
2
) ser descartado
por la heurstica 1. Debemos destacar tambin que parMasCercano.distancia puede
actualizarse con la distancia de un par de objetos (o
11
, o
21
) (||(o
11
, o
21
)||
parMasCercano.distancia) o con el valor de MinMaxDist de un par de MBRs (R
1
, R
2
) que se
encuentra en la misma lista de pares de MBRs ordenados segn MinMaxDist procedente de la
combinacin de dos nodos internos de dos R*-trees. Si slo utilizamos la heurstica 1 sin
utilizar la heurstica 2, debemos considerar dos casos para demostrar la consecuencia de
nuestra implicacin.
Caso 1. La poda de un par de MBRs (R
1
, R
2
) puede deberse a que se haya podado un par de
MBRs ancestro. Puesto que si (R
1
, R
2
) no est en las races respectivas de los dos R*-trees,
entonces debe haber un par ancestro a (R
1
, R
2
) que se procese antes que ste, sea este par de
MBRs ancestro (R
1
, R
2
). Por el Lema 6.2, el par de MBRs ancestro (R
1
, R
2
) tiene que
tener un valor de MinMinDist menor que ||(o
11
, o
21
)|| (MinMinDist(R
1
, R
2
) < ||(o
11
, o
21
)||), y
esto tambin se verifica para todos los pares de MBRs ancestros entre (R
1
, R
2
) y (R
1
, R
2
).
Si (R
1
, R
2
) se poda, entonces dicha poda se debe a la heurstica 1 aplicada a algunos de sus
ancestros, de la misma forma que se puede llevar a cabo utilizando la heurstica 2
(MinMinDist(R
1
, R
2
) > MinMaxDist(R
1
, R
2
) entonces el par (R
1
, R
2
) ser descartado).
Captulo 6
184
Caso 2. La poda de un par de MBRs (R
1
, R
2
) puede deberse tambin a que
parMasCercano.distancia sea actualizada con la distancia de un par de objetos (o
11
, o
21
) que
ha sido considerado como candidato temporal a ser el ms cercano. Sea
parMasCercano.distancia la distancia del par de objetos ms cercano antes de podar el par de
MBRs (R
1
, R
2
). Puesto que, para actualizar parMasCercano.distancia se debe haber
verificado que parMasCercano.distancia ||(o
11
, o
21
)||, y adems se cumple que
MinMinDist(R
1
, R
2
) < ||(o
11
, o
21
)|| antes de que (R
1
, R
2
) se pode, entonces MinMinDist(R
1
,
R
2
) > parMasCercano.distancia y el par de MBRs (R
1
, R
2
) se podar por la heurstica 1, de
la misma forma que se puede llevar a cabo utilizando la heurstica 2 (MinMinDist(R
1
, R
2
) >
MinMaxDist(R
1
, R
2
) entonces el par (R
1
, R
2
) ser descartado).
De este lema podemos concluir que todos los pares que se podan por la heurstica 1 sin
utilizar la heurstica 2, son los mismos que se podan por la heurstica 1 utilizando la heurstica
2, una vez que parMasCercano.distancia ha sido actualizado a nivel de hojas en el algoritmo
CPC_Recursivo_MINMAXDIST_MINMINDIST_Ordenado.
Teorema 6.1.
Dado el algoritmo branch-and-bound
CPC_Recursivo_MINMAXDIST_MINMINDIST_Ordenado, si un par de MBRs se poda
por la heurstica 1 (MinMinDist) utilizando previamente la heurstica 2 (MinMaxDist), este
par se podar de igual forma sin utilizar la heurstica 2 (MinMaxDist).
Demostracin:
Para demostrar este teorema debemos considerar la siguiente equivalencia:
poda con heurstica 1 utilizando la heurstica 2 poda con heurstica 1 sin utilizar la
heurstica 2
1. poda con heurstica 1 utilizando la heurstica 2 poda con heurstica 1 sin utilizar la
heurstica 2. La demostracin de esta implicacin se obtiene de forma inmediata del
Lema 6.5.
2. poda con heurstica 1 sin utilizar la heurstica 2 poda con heurstica 1 utilizando la
heurstica 2. La demostracin de esta implicacin se obtiene de forma inmediata del
Lema 6.6.
Como aclaracin, si un acceso a un nodo en un R*-tree se corresponde con un acceso a
disco, entonces utilizar la heurstica de poda 1 previa utilizacin de la heurstica 2 (una vez
que parMasCercano.distancia ha sido actualizado a nivel de hojas) no supone ningn ahorro
en el nmero de accesos a disco comparado con utilizar nicamente la heurstica 1, aplicadas
en un algoritmo branch-and-bound recursivo para CPC, ordenando los pares de MBRs
procedentes de la combinacin de dos nodos internos de dos R*-trees segn su MinMinDist
(CPC_Recursivo_MINMAXDIST_MINMINDIST_Ordenado).
La conclusin que podemos obtener de este teorema es que actualizar
parMasCercano.distancia (una vez que ste ha sido actualizado a nivel de hojas) con la
heurstica 2 (basada en MinMaxDist) a nivel local no supone ningn ahorro en el nmero de
accesos a disco, aplicada sobre un algoritmo recursivo para CPC, ordenando los pares de
MBRs procedentes de la combinacin de dos nodos internos de dos R*-trees segn su
Resultados experimentales y aplicacin
185
MinMinDist (CPC_Recursivo_MINMAXDIST_MINMINDIST_Ordenado). Por otro lado,
no utilizar dicha heurstica supone un ahorro de clculo, pues obtener el valor de MinMaxDist
entre dos MBRs tiene un coste que depende del nmero de dimensiones que intervienen en la
operacin.
La demostracin para K-CPC utilizando la heurstica 2 basada en MaxMaxDist(R
1
, R
2
) y
aplicada a la extensin del anterior algoritmo branch-and-bound recursivo propuesta en el
captulo 5 (KCPC_Recursivo_MAXMAXDIST_MINMINDIST_Ordenado) es muy
similar. Dicha heurstica de poda nos dice, de forma general, que actualizar la variable
distanciaPodaKCPC utilizando MaxMaxDist, la altura de los R*-trees y su mnimo valor de
factor de ramificacin (m
1
, m
2
), podaba subrboles de los R*-trees para K-CPC de la misma
manera que la heurstica de poda basada en MinMaxDist lo hace para CPC.
La demostracin para el algoritmo recursivo optimizado con la tcnica del barrido del
plano y para el iterativo basado en una poltica de bsqueda de primero el mejor (minimiza el
nmero de pares de MBRs a procesar antes de devolver el resultado final) es muy similar a la
estudiada para el algoritmo recursivo siguiendo un esquema de recorrido en profundidad y
que ordena los pares de MBRs segn su MinMinDist. Por ello, aplicar estas heursticas de
poda para CPC (MinMaxDist) y K-CPC (MaxMaxDist) no supone ningn ahorro en el
nmero de accesos a disco una vez alcanzado el nivel de hojas, pero s reduce notablemente el
nmero de pares de MBRs insertados en el montculo principal empleado para esta versin
iterativa, tal y como observamos en los resultados experimentales para este parmetro.
Por tanto, la heurstica 1 es la realmente eficiente para el proceso de poda durante la
ejecucin de algoritmos branch-and-bound tanto recursivos como iterativos, que deca si
MinMinDist(R
1
, R
2
) > valorCotaTemporal, entonces el par de MBRs (R
1
, R
2
) puede ser
descartado, siendo valorCotaTemporal igual a parMasCercano.distancia (CPC) o
distanciaPodaKCPC (K-CPC), respectivamente.

Influencia de la cardinalidad y naturaleza de los conjuntos de datos (puntos)
Otros parmetros importantes que afectan a esta consulta son la cardinalidad y naturaleza de
los conjuntos de datos (puntos). En la Figura 6.4 podemos observar para CPC, combinando
puntos reales con reales movidos aleatoriamente y diferentes cardinalidades 10000 (10K),
30000 (30K), 60000 (60K) y 120000 (120K) puntos, que HEAP_SIM es la mejor alternativa
respecto a nmero de accesos a disco cuando los rboles tienen la misma altura (R/10K,
R/30K y R/60K) y BFT_SIM es la peor. Pero cuando las alturas son diferentes (R/120K), las
variantes del algoritmo recursivo nos proporcionan los mejores resultados (Fijar las Hojas),
volviendo a ser BFT_SIM la peor alternativa. Las tendencias de los resultados cuando los
puntos que se combinaron haban sido generados aleatoriamente y siguiendo una distribucin
uniforme fueron similares (resultados no mostrados aqu).
Captulo 6
186
0
15000
30000
45000
60000
75000
R/10K R/30K R/60K R/120K
Combinacin de los Conjuntos de Datos
A
c
c
e
s
o
s

a

D
i
s
c
o
RECU_EXH RECU_STD HEAP_SIM BFT_SIM

Figura 6.4 CPC, combinando puntos reales con reales movidos aleatoriamente.
Segn la Figura 6.5, los algoritmos recursivos (RECU_EXH y RECU_STD) no se ven
muy afectados por el cambio de cardinalidad, incluso cuando este cambio provoca que las
alturas de los R*-trees sean diferentes, fenmeno que si se aprecia en los algoritmos iterativos
(HEAP_SIM y BFT_SIM). En ambos casos, el incremento de K se puede apreciar con ms
notoriedad cuando pasamos de K = 10000 a K = 100000, aunque para los algoritmos
recursivos dicho incremento es menos pronunciado.

1
10
100
1000
10000
100000
10K
30K
60K
120K
0
14000
28000
42000
56000
70000
A
c
c
e
s
o
s

a

D
i
s
c
o
Nmero de Pares
Conjuntos
0-14000 14000-28000 28000-42000 42000-56000 56000-70000

1
10
100
1000
10000
100000
10K
60K 0
14000
28000
42000
56000
70000
A
c
c
e
s
o
s

a

D
i
s
c
o
Nmero de Pares
Conjuntos
0-14000 14000-28000 28000-42000 42000-56000 56000-70000

RECU_EXH RECU_STD

Resultados experimentales y aplicacin
187
1
10
100
1000
10000
100000
10K
30K
60K
120K
0
18000
36000
54000
72000
90000
A
c
c
e
s
o
s

a

D
i
s
c
o
Nmero de Pares
Conjuntos
0-18000 18000-36000 36000-54000 54000-72000 72000-90000

1
10
100
1000
10000
100000
10K
30K
60K
120K
0
22000
44000
66000
88000
110000
A
c
c
e
s
o
s

a

D
i
s
c
o
Nmero de Pares
Conjuntos
0-22000 22000-44000 44000-66000 66000-88000 88000-110000

HEAP_SIM BFT_SIM
Figura 6.5 Comportamiento de K-CPC para los algoritmos recursivos e iterativos, cuando
combinamos puntos reales con reales movidos aleatoriamente y de cardinalidades diferentes.

1 10 100 1000 10000 100000
RECU_EXH 33624 33760 34170 35646 40752 59206
RECU_STD 33598 33730 34112 35478 40166 56006
HEAP_SIM 33588 33656 33880 34612 37102 45588
BFT_SIM 34232 34300 34576 35382 38200 47104
Tabla 6.5 Nmero de accesos a disco para K-CPC utilizando RECU_EXH, RECU_STD,
HEAP_SIM y BFT_SIM para puntos reales y reales movidos aleatoriamente.
0
12000
24000
36000
48000
60000
1 10 100 1000 10000 100000
Nmero de Pares
A
c
c
e
s
o
s

a

D
i
s
c
o
RECU_EXH RECU_STD HEAP_SIM BFT_SIM

Figura 6.6 Comportamiento de K-CPC para RECU_EXH, RECU_STD, HEAP_SIM y
BFT_SIM para puntos reales y reales movidos aleatoriamente (60K = 60000 puntos).
El diagrama de barras de la Figura 6.6 (datos de la Tabla 6.5) nos indica que cuando los
conjuntos de datos (puntos) tienen una cardinalidad que da lugar a R*-trees con la misma
altura, HEAP_SIM es siempre la mejor alternativa, mientras que las versiones recursivas
(RECU_EXH y RECU_STD) muestran un peor comportamiento cuando K 1000, y
BFT_SIM lo es cuando K 100. Debemos sealar tambin que combinando conjuntos de
Captulo 6
188
datos (puntos) con diferente naturaleza (uniforme y aleatoria), y teniendo una cardinalidad
para que los dos R*-trees tengan la misma altura, la tendencia de los resultados fue muy
similar a la mostrada en la Figura 6.6 (resultados no mostrados aqu).
Tomando como referencia HEAP_SIM, hemos estudiado el efecto de considerar la mejor
poltica de tratamiento de empates (menor nivel y MBR ms pequeo en caso de empate) y no
considerar ninguna. Todos ellos sobre diferentes cardinalidades y naturalezas de datos, con
respecto al nmero mximo de pares de MBRs almacenados en el montculo mnimo principal
y el nmero de inserciones en dicha estructura de datos. En estos experimentos, se ha
considerado el efecto de aadir MaxMaxDist, ya que como se ha comprobado anteriormente
afecta beneficiosamente a estos dos parmetros.

Tratamiento de empates sobre pares de MBRs con el mismo valor de MinMinDist
Para estudiar el efecto del tratamiento de empates (pares de MBRs con el mismo valor de
MinMinDist) hemos considerado las 8 polticas enunciadas en el captulo 4, obteniendo las
dos siguientes conclusiones:
1. Respecto al nmero de accesos a disco tanto para CPC como para K-CPC, los nicos
algoritmos afectados fueron las variantes recursivas (en particular SIM y PS), siendo la
mejor alternativa considerar el menor nivel y MBR ms pequeo (en base a su rea) en
caso de que todos los MBRs tengan el mismo nivel, ya que esto supone alcanzar el nivel
de las hojas de los R*-trees ms rpidamente. Sin embargo, no considerar ningn
tratamiento para el empate proporcion resultados muy interesantes, en algunos casos
incluso mejores que los de la mejor variante. El resto de alternativas para el tratamiento
de empates no superaron en ningn momento a las dos anteriores. Tambin es preciso
indicar que para los algoritmos recursivos el porcentaje de mejora fue inferior al 1%
para todas las configuraciones lo que indica que no es suficientemente beneficioso
aplicar el tratamiento de empates respecto al nmero de accesos a disco.
2. Los algoritmos iterativos tanto para CPC como para K-CPC no se ven afectados en
cuanto al nmero de accesos a disco, pero s respecto al tamao mximo del montculo
principal y al nmero de inserciones en dicha estructura de datos (Tablas 6.6 y 6.7).

1 10 100 1000 10000 100000
R/R 416 2452 459 2561 677 3322 1479 5265 4267 9861 18457 34518
83.03% 82.07% 79.62% 71.91% 56.72% 46.52%
R/U60K 338 1882 385 1822 567 2287 1277 3450 3939 9207 17348 24931
82.04% 78.86% 75.21% 62.98% 57.21% 30.41%
R/U120K 209 2107 288 2143 524 3055 1414 5582 4491 11312 17079 33104
90.08% 86.56% 82.84% 74.66% 60.29% 48.41%
R/A30K 318 2078 366 2246 537 2437 1130 3304 3726 9398 15828 26333
84.69% 83.70% 77.96% 65.79% 60.35% 39.89%
A/U10K 202 1384 248 1376 406 1941 994 3111 4062 6819 15084 23493
85.41% 81.97% 79.08% 68.04% 40.43% 35.79%
Tabla 6.6 Tamao mximo del montculo, considerando y sin considerar un tratamiento de
empates.
Resultados experimentales y aplicacin
189

1 10 100 1000 10000 100000
R/R 19195 19880 19272 19963 19501 20500 20313 22602 23139 27678 37420 52164
3.45% 3.46% 4.87% 10.13% 16.41% 28.26%
R/U60K 11652 12376 11712 12486 11898 12769 12623 14112 15340 19714 28860 35718
5.85% 6.20% 6.82% 10.55% 22.19% 19.20%
R/U120K 24193 25322 24299 25419 24546 25796 25477 28389 28705 34562 42069 57284
4.46% 4.41% 4.85% 10.26% 16.95% 26.56%
R/A30K 8436 9277 8496 9375 8685 9726 9296 10834 11908 16188 24168 34193
9.07% 9.38% 10.70% 14.20% 26.44% 29.32%
A/U10K 7300 7829 7353 7897 7525 8135 8115 8963 11196 13034 22308 29967
6.76% 6.89% 7.51% 9.46% 14.11% 25.56%
Tabla 6.7 Nmero de inserciones en el montculo principal, considerando y sin considerar un
tratamiento de empates. Donde R/R = Real/Real, R/U = Real/Uniforme, R/A =
Real/Aleatorio, A/U = Aleatorio/Uniforme y 30K = 30000.
En las Tablas 6.6 y 6.7 se puede observar que el tratamiento de empates sobre pares de
MBRs con el mismo valor de MinMinDist produce un efecto beneficioso para los algoritmos
iterativos que usan un montculo mnimo principal global (HEAP) independientemente de la
cardinalidad y naturaleza de los datos que intervienen en la consulta. Conforme aumenta el
valor de K, el porcentaje respecto al tamao mximo del montculo principal de ganancia al
aplicar el tratamiento de empates se reduce. Por otro lado, respecto al nmero de inserciones,
al aumentar K aumenta tambin el porcentaje de ahorro al aplicar la mejor poltica para el
tratamiento de empates.
Las Tablas 6.8 y 6.9 comparan las dos alternativas iterativas (HEAP y BFT) para resolver
la consulta de los pares ms cercanos en su variante SIM, respecto al tamao mximo del
montculo principal (global o por niveles) y al nmero de inserciones de pares de MBRs en l.
En los experimentos se considera MaxMaxDist y la mejor poltica para el tratamiento de
empates (menor nivel y MBR ms pequeo en caso de empate), ya que afectan
considerablemente a estos dos parmetros en estudio. De los resultados obtenidos podemos
concluir que utilizar HEAP es considerablemente mejor que BFT como alternativa iterativa
para resolver la consulta, debido a que el ahorro de memoria para el montculo principal es
muy grande (75%-99%) y en lo que respecta al nmero de inserciones es tambin importante
el ahorro que se produce (50%-75%).

1 10 100 1000 10000 100000
R/R 416 43123 459 43123 677 45230 1479 50498 4267 64840 18457 99509
99.04% 98.94% 98.50% 97.07% 93.42% 81.45%
R/U60K 338 33276 385 33276 567 37466 1277 44188 3939 56953 17348 88321
98.98% 98.84% 98.49% 97.11% 93.08% 80.36%
R/U120K 209 76365 288 76365 524 78762 1414 85664 4491 104166 17079 146779
99.73% 99.62% 99.33% 98.35% 95.69% 88.36%
R/A30K 318 29485 366 29485 537 31371 1130 36094 3726 46976 15828 71991
98.92% 98.76% 98.29% 96.87% 92.07% 78.01%
A/U10K 202 25904 248 25904 406 27286 994 31791 4062 41097 15084 63477
99.22% 99.04% 98.51% 96.875 90.12% 76.24%
Tabla 6.8 Tamao mximo del montculo principal, para HEAP y BFT.

Captulo 6
190
1 10 100 1000 10000 100000
R/R 19195 43306 19272 43306 19501 45413 20313 50681 23139 65023 37420 99692
55.68% 55.50% 57.06% 59.92% 64.41% 62.46%
R/U60K 11652 33471 11712 33471 11898 37661 12623 44383 15340 57148 28860 88516
65.19% 65.01% 68.41% 71.56% 73.16% 67.40%
R/U120K 24193 78571 24299 78571 24546 80968 25477 87870 28705 106372 42069 149198
69.21% 69.07% 69.68% 71.01% 73.01% 71.80%
R/A30K 8436 29624 8496 29624 8685 31510 9296 36233 11908 47115 24168 72130
71.52% 71.32% 72.44% 74.34% 74.73% 66.49%
A/U10K 7300 25958 7353 25958 7525 27340 8115 31845 11196 41151 22308 63531
71.88% 71.67% 72.48% 74.52% 72.79% 64.89%
Tabla 6.9 Nmero de inserciones en el montculo principal, para HEAP y BFT. Donde R/R =
Real/Real, R/U = Real/Uniforme, R/A = Real/Aleatorio, A/U = Aleatorio/Uniforme y 30K =
30000.

Evaluacin del tiempo de respuesta
Por ltimo, el parmetro que vamos a estudiar es el tiempo de respuesta medido en segundos
para cada una de las variantes de los algoritmos recursivos e iterativos. Para evaluar la
consulta hemos utilizado conjuntos de datos (puntos) reales y reales movidos aleatoriamente
con la misma cardinalidad (62556), aunque con cardinalidades y naturaleza de datos
diferentes, las tendencias de los resultados fueron similares (resultados no mostrados aqu).

RECU HEAP BFT
EXH 4.04 4.69
SIM 14.65 15.35 22.67
STD 16.89 17.24 18.07
STM 16.64 16.71 17.23
PS 1.68 2.49 3.81
Tabla 6.10 Tiempo de respuesta en segundos para CPC.
De la Tabla 6.10 podemos extraer varias conclusiones interesantes para CPC:
1. La versin recursiva es la ms rpida, aunque la diferencia con respecto a la versin
iterativa que utiliza un montculo global (HEAP) es menor que emplear la alternativa
que organiza el montculo principal por niveles junto con un recorrido en anchura
(BFT). Es evidente que la gestin del montculo principal requiere su tiempo y hacerlo
por niveles es ms costoso.
2. Debido a que PS est pensada como variante que optimiza el tiempo de respuesta (no
considera la combinacin de todos los MBRs de un nodo con todos los del otro como
hacen las otras variantes) no utiliza MinMaxDist, y por ello proporciona los mejores
resultados en lo que respecta al tiempo requerido por la consulta en cuestin, siendo del
orden del 58% (2.36 segundos) ms rpida que EXH en la versin recursiva y del 47%
(2.2 segundos) para la iterativa. Adems, utilizar la versin recursiva de PS supone una
mejora del 32% con respecto a la versin iterativa utilizando un montculo global
(HEAP).
Resultados experimentales y aplicacin
191
3. Aplicar MinMaxDist (SIM) hace que el algoritmo sea ms lento respecto a no
considerarla (EXH), produciendo un retardo del orden del 72% (10.61 segundos) para el
algoritmo recursivo y del 69% (10.66 segundos) para el iterativo.
4. Las variantes que ordenan los pares de MBRs en base a su MinMinDist son los que ms
tiempo necesitan, ya que adems de considerar MinMaxDist necesitan un tiempo
adicional para ordenar la lista de pares (STD) o mantener un montculo mnimo local
(STM). El retardo producido con respecto a EXH es del (76%, 73%) para STD y del
(75%, 72%) para STM en lo que respecta a las alternativas recursiva e iterativa,
respectivamente. De estas dos variantes, STM es la que tiene un tiempo de respuesta
sensiblemente menor para todos los algoritmos.
5. Por ltimo, BFT es el algoritmo que proporciona los resultados ms elevados para este
parmetro en evaluacin. Esto es debido fundamentalmente a la gestin que tiene que
hacer sobre el montculo principal organizado por niveles, que como hemos visto, hace
que ste tenga muchos ms pares almacenados en l y por tanto el nmero de
inserciones sea tambin mayor que considerar un montculo mnimo gestionado de
forma global (HEAP) como alternativa iterativa.

1 10 100 1000 10000 100000
R+KCVP 26.04 35.15 105.70 788.80 6586.97 29723.11
RECU_BRU 4179.41 4165.85 4166.21 4183.06 4170.73 4182.11
RECU_EXH 4.98 5.00 5.08 5.41 7.15 19.88
RECU_SIM 5.12 5.13 5.22 5.57 7.33 20.93
RECU_STD 17.18 17.59 17.71 18.07 19.46 31.51
RECU_STM 18.03 17.96 18.04 18.39 20.16 32.34
RECU_PS 1.66 1.67 1.74 2.01 3.44 15.62
HEAP_EXH 6.37 5.82 5.83 6.08 7.42 14.60
HEAP_SIM 6.31 5.89 5.91 6.13 7.45 15.46
HEAP_STD 19.42 19.12 19.18 19.54 21.31 29.30
HEAP_STM 17.44 17.70 17.72 17.97 19.01 27.47
HEAP_PS 2.46 2.49 2.61 3.23 4.76 13.37
BFT_SIM 8.07 7.08 7.31 7.96 10.03 19.33
BFT_STD 23.20 22.86 23.20 24.55 28.16 40.85
BFT_STM 21.14 21.34 21.69 22.75 25.80 38.08
BFT_PS 3.84 3.84 4.13 4.87 7.38 18.17
Tabla 6.11 Tiempo de respuesta en segundos para K-CPC sin considerar MaxMaxDist ni el
tratamiento de empates.


Captulo 6
192
1 10 100 1000 10000 100000
RECU_BRU 4179.41 4165.85 4166.21 4183.06 4170.73 4182.11
RECU_EXH 5.02 5.03 5.13 5.48 7.22 19.83
RECU_SIM 5.61 5.62 5.71 6.04 7.78 20.91
RECU_STD 18.04 17.95 18.01 18.34 20.24 30.78
RECU_STM 18.54 18.63 18.69 19.03 20.79 31.61
RECU_PS 2.13 2.15 2.22 2.51 4.21 16.37
HEAP_EXH 5.75 5.76 5.78 6.01 7.38 14.58
HEAP_SIM 7.37 6.37 6.45 6.78 7.99 16.32
HEAP_STD 19.70 19.99 20.02 20.36 21.79 30.56
HEAP_STM 18.06 17.85 17.91 18.47 19.68 28.39
HEAP_PS 2.92 2.93 3.06 3.39 4.70 13.18
BFT_SIM 157.04 156.81 159.45 162.14 157.97 179.05
BFT_STD 166.31 166.37 169.40 173.35 171.11 196.55
BFT_STM 165.10 164.96 168.07 172.06 169.56 193.75
BFT_PS 152.54 152.59 175.33 159.22 155.36 176.40
Tabla 6.12 Tiempo de respuesta en segundos para K-CPC considerando MaxMaxDist y el
tratamiento de empates.
De las Tablas 6.11 y 6.12 podemos extraer las mismas conclusiones para K-CPC que las
obtenidas para CPC respecto al tiempo de respuesta en segundos. Adems, si no
consideramos MaxMaxDist ni el tratamiento de empates (Tabla 6.11) obtenemos menor
tiempo de respuesta que considerndolos (Tabla 6.12). La razn es que, teniendo en cuenta
estos parmetros para reducir el tamao del montculo y el nmero de inserciones en l hace
que el tiempo global requerido por la consulta sea mayor. Este fenmeno se ve seriamente
agravado para BFT, ya que dicho tratamiento lo tiene que hacer de forma local en cada nivel
con cada uno de los montculos que se van generando. Tambin es interesante destacar que
todas las versiones de HEAP, cuando K = 100000 tienen un tiempo de respuesta menor que
sus homnimas del algoritmo recursivo. Por este motivo, se han repetido los experimentos
para K = 200000, 500000 y 1000000, estudiando el comportamiento de los algoritmos cuando
K aumenta notablemente su valor. La Tabla 6.13 muestra los resultados de dicha
experimentacin, destacando que cuando K 100000, HEAP_PS es la alternativa ms rpida.

100000 200000 500000 1000000
RECU_EXH 19.88 34.11 74.05 130.77
RECU_SIM 20.93 35.97 75.60 133.82
RECU_STD 31.51 44.28 70.09 109.30
RECU_STM 32.34 42.16 69.93 110.65
RECU_PS 15.62 34.00 68.87 127.89
HEAP_EXH 14.60 22.38 35.93 50.70
HEAP_SIM 15.46 22.49 36.59 51.23
HEAP_STD 29.30 36.05 49.68 66.77
HEAP_STM 27.47 35.04 47.63 63.51
HEAP_PS 13.37 20.63 35.45 50.45
BFT_SIM 19.33 31.2 48.34 77.04
BFT_STD 40.85 47.33 73.02 103.98
BFT_STM 38.08 47.16 66.07 104.31
BFT_PS 18.17 25.13 42.56 76.6
Tabla 6.13 Tiempo de respuesta en segundos para K-CPC sin
considerar MaxMaxDist ni el tratamiento de empates.
Resultados experimentales y aplicacin
193
Para ilustrar la tendencia de los algoritmos respecto al tiempo de respuesta hemos
seleccionado las dos mejores variantes de los algoritmos recursivos (RECU_EXH y
RECU_PS) e iterativos (HEAP_EXH y HEAP_PS) dando lugar a la Figura 6.7. Como se
puede observar en dicha figura, el incremento de tiempo que sufren los algoritmos recursivos
conforme los valores de K se hacen extremadamente grandes no se aprecia para los iterativos,
cuya tendencia es mucho ms suave y no tan pronunciada. Este fenmeno es debido
fundamentalmente a dos factores: el valor de K y la tcnica utilizada para el recorrido de los
R*-trees. Cuanto mayor es el valor de K, despus de llenar el montculo mximo adicional
donde se almacena en resultado (KMasCercanos), se necesitan ms operaciones de
actualizacin (inserciones y borrados) sobre dicha estructura de datos con el objetivo de dejar
los K pares de objetos ptimos. Por ello, el algoritmo recursivo que sigue un recorrido
sincronizado en profundidad sobre los dos R*-trees requerir muchas llamadas recursivas
hasta dejar en KMasCercanos los K pares de objetos ms cercanos. Por otra parte, el
algoritmo iterativo que utiliza una estrategia de bsqueda de primero el mejor basada en un
montculo mnimo global, cuando alcanza el nivel de las hojas, produce los mejores pares
candidatos, obteniendo muy rpidamente los K ms cercanos y tendiendo que realizar menos
operaciones de actualizacin sobre KMasCercanos. Por ello, HEAP gasta menos tiempo en la
respuesta a la consulta y tiene un nmero de accesos a disco menor.
0
28
56
84
112
140
1 10 100 1000 10000 100000 200000 500000 1000000
Nmero de Pares
T
i
e
m
p
o

d
e

R
e
s
p
u
e
s
t
a

(
s
e
g
.
)
RECU_EXH RECU_PS HEAP_EXH HEAP_PS

Figura 6.7 Tiempo de respuesta para K-CPC aplicado a las mejores alternativas recursivas
e iterativas.
Tambin hemos comprobado que cuando los valores de K son bastante grandes (200000,
500000 y 1000000) el comportamiento para los R*-trees con la misma altura frente a nmero
de accesos a disco se mantiene. Es decir, la mejor alternativa es HEAP, seguido de BFT y por
ltimo la versin recursiva.



Captulo 6
194
6.2.4 Conclusiones

Las conclusiones generales que podemos extraer de esta fase experimental son las siguientes:
1. Respecto al nmero de accesos a disco:
1.1. La mejor alternativa para CPC y K-CPC es HEAP (iterativo) siempre que los R*-
trees tengan la misma altura, mientras que con alturas diferentes (Fijar las Hojas) las
variantes recursivas proporcionaron los mejores resultados. BFT demostr ser la peor
alternativa, aunque cuando K 100 obtuvo mejores resultados que las variantes
recursivas. De estas ltimas, STD y STM fueron sensiblemente mejores al resto, ya
que ordenar los pares de MBRs segn MinMinDist a nivel local provoca que los
pares de objetos ms cercanos se encuentren con mayor rapidez.
1.2. Aplicar MinMaxDist para CPC y MaxMaxDist para K-CPC no supone un ahorro
sustancial en el nmero de operaciones de E/S para casi ninguna alternativa. Igual
ocurre cuando hay varios pares de MBRs con el mismo valor de MinMinDist.
1.3. La naturaleza de los datos no supone un factor determinante considerando fija la
cardinalidad de los conjuntos de datos (puntos) que intervienen en la consulta y el
orden (m, M) de los R*-trees.
1.4. La cardinalidad (mientras exista el mismo grado de solape entre los conjuntos de
datos) es un factor importante, mxime cuando sta provoca una diferencia de altura
de los R*-trees (con el mismo orden).
1.5. Las diferentes variantes de HEAP y BFT no se ven afectadas, obteniendo todas ellas
el mismo nmero de accesos a disco.
2. Respecto al tamao mximo y al nmero de inserciones del/en montculo principal
para los algoritmos iterativos.
2.1. Utilizar MaxMaxDist y la mejor poltica de tratamiento de empates (los MBRs que
forman el par tienen el mismo valor de MinMinDist) nos proporcionan una
considerable reduccin de ambos parmetros para K-CPC.
2.2. Ya que aplicar estas dos tcnicas (MaxMaxDist y tratamiento de empates) tiene
mayor trascendencia en los algoritmos iterativos, se ha observado que HEAP tiene un
comportamiento mucho mejor que BFT ante estos parmetros.
2.3. Adems, aplicar la heurstica de poda basada en MaxMaxDist y el tratamiento de
empates supone un gasto extra en el tiempo de respuesta requerido por la consulta.
3. Respecto al tiempo global de respuesta para CPC y K-CPC utilizando R*-trees con la
misma altura y con conjuntos de datos (puntos) reales y reales movidos aleatoriamente:
Resultados experimentales y aplicacin
195
3.1. La versin recursiva es la ms rpida, aunque cuando los valores de K son muy
grandes (K 100000) las alternativas iterativas tienen un mejor comportamiento ante
este parmetro, siendo HEAP la mejor de ellas.
3.2. La variante PS es la que menor tiempo necesita para la ejecucin de las consultas,
destacando que EXH tiene un comportamiento muy cercano a PS.
3.3. Aplicar la heursticas de poda basadas en MinMaxDist (CPC) y MaxMaxDist (K-
CPC), junto con el tratamiento de empates hace que los algoritmos sean ms lentos,
pues necesitan un procesamiento extra para poder llevar a cabo dicha consulta.
En base a los resultados obtenidos en esta primera fase experimental, una de las principales
conclusiones que podemos extraer es que HEAP tiene el mejor comportamiento como
algoritmo iterativo para todos los parmetros en estudio, descartando a BFT para los
sucesivos experimentos. Por tanto, se entiende que es mejor organizar un montculo de forma
global (HEAP) que por niveles siguiendo un recorrido en anchura (BFT).

6.3 Utilizacin de R*-trees con diferentes alturas

Como complemento a la anterior seccin experimental vamos a realizar un estudio del
comportamiento que tienen los algoritmos recursivos e iterativos (HEAP, ya que siempre
muestra mejores resultados que BFT) cuando en la consulta intervienen dos R*-trees con
diferentes alturas. Para ello, vamos a evaluar el comportamiento de las dos tcnicas descritas
en el captulo 5: Fijar las Hojas y Fijar la Raz, que denotaremos como FH y FR,
respectivamente.

Evaluacin del nmero de accesos a disco
En primer lugar, en la Tabla 6.14 presentamos los resultados del nmero de accesos a disco al
aplicar CPC tanto para las versiones recursivas (RECU) como para las iterativas (HEAP).
Para realizar dichos experimentos, hemos utilizado conjuntos de datos (puntos) reales y reales
movidos aleatoriamente (de un punto real obtenemos dos puntos en posiciones aleatorias
diferentes) completamente solapados con diferentes cardinalidades (62556 y 125112) dando
lugar a R*-trees con diferentes alturas (4 y 5), aunque para conjuntos de datos con diferente
naturaleza (uniformes y aleatorios) las tendencias fueron similares. De la Tabla 6.14 podemos
obtener algunas conclusiones importantes:
1. El algoritmo recursivo utilizando la tcnica de Fijar las Hojas proporciona los mejores
resultados, debido a que sigue un recorrido sincronizado en profundidad en ambos R*-
trees, alcanzando las hojas y actualizando el valor de parMasCercano.distancia muy
rpidamente.
Captulo 6
196
2. Aplicar la tcnica de Fijar la Raz es beneficioso para el algoritmo iterativo, ya que ste
sigue un recorrido basado en una poltica de primero el mejor, y cuantos ms MBRs
combine en niveles superiores, el valor de parMasCercano.distancia se reducir ms
rpidamente, haciendo que la poda sea ms efectiva.
3. Cuando aplicamos la tcnica de Fijar la Raz a CPC, tanto para los algoritmos
recursivos como para los iterativos, los resultados han sido muy prximos (HEAP
ligeramente mejor). Por tanto, podemos observar que esta tcnica reduce la potencia de
los algoritmos recursivos (necesita combinar ms nodos internos antes de llegar a las
hojas sin reducir notablemente el valor de parMasCercano.distancia) y aumenta el
rendimiento de los iterativos (combina ms pares de nodos internos, actualiza ms
rpidamente el valor de parMasCercano.distancia y por ello la poda es ms efectiva
cuando se combinan ms pares de MBRs de niveles superiores).

RECU HEAP
FH FR FH FR
EXH 49826 55616 75016 55458
SIM 49776 55496 75016 55458
STD 49759 55468 75016 55458
STM 49759 55458 75016 55458
PS 49784 55498 75016 55458
Tabla 6.14 Nmero de accesos a disco para CPC sobre
R*-trees con diferentes alturas.
Sobre los mismos conjuntos de datos indexados en sendos R*-trees hemos aplicado el
algoritmo recursivo y el iterativo en la variante STD sobre K-CPC con las dos tcnicas
mencionadas anteriormente para el tratamiento de R*-trees con diferentes alturas (FH y FR),
obteniendo los resultados que se muestran en la Tabla 6.15 y la Figura 6.8, junto a
conclusiones similares a las anteriores tales como:
1. Para el algoritmo recursivo, la alternativa STD (el comportamiento de STM fue muy
similar) present los mejores resultados excepto para K = 1000000, despus de aplicar
las tcnicas Fijar las Hojas (FH) y Fijar la Raz (FR). Por el contrario, el algoritmo
iterativo utilizando la tcnica Fijar la Raz obtuvo el menor nmero de accesos para K =
1000000, esto se debe fundamentalmente a la forma de recorrer los R*-trees que
intervienen en la consulta. Los algoritmos iterativos, utilizando un montculo mnimo
global siguen una poltica de seleccin de primero el mejor, y cuando empiezan a
procesar las hojas encontrarn rpidamente los K ptimos puesto que extraern del
montculo los mejores pares candidatos segn MinMinDist. Por otro lado, los algoritmos
recursivos, cuanto mayor es el K, para llenar y actualizar KMasCercanos necesitan la
realizacin de muchas llamadas recursivas para dejar al final los K pares ptimos,
debido a que sigue un recorrido sincronizado en profundidad en ambos R*-trees.
2. Las variantes de los algoritmos iterativos no se ven afectadas para un determinado valor
de K, independientemente de que se aplique FH o FR, al igual que ocurra en el caso de
que los R*-trees tuvieran la misma altura.
3. Aplicar Fijar la Raz (FR) supone un ahorro en el nmero de accesos a disco con
respecto a Fijar las Hojas (FH) para el algoritmo iterativo segn el valor de K del
Resultados experimentales y aplicacin
197
(0.02%, 0.10%, 0.59%, 2.02%, 6.15%, 18.23% y 38.13%). En cambio, para el algoritmo
recursivo en su variante STD supone un gasto extra del (50.76%, 50.71%, 50.22%,
49.03%, 45.09%, 33.57% y 9.15%). Esto nos permite resaltar dos aspectos: (1) los
algoritmos iterativos se ven ms afectados que los recursivos cuando se utiliza
MaxMaxDist para actualizar distanciaPodaKCPC, puesto que la actualizacin a nivel
global (iterativos) es ms beneficiosa que la local (recursivos), y (2) fijar la raz del R*-
tree con menor altura para el algoritmo recursivo supone un procesamiento extra de los
niveles del R*-tree con mayor altura sin realizar una actualizacin lo suficientemente
efectiva sobre distanciaPodaKCPC.
4. La tcnica Fijar la Raz hace que los algoritmos iterativos tengan un nmero menor de
accesos a disco que los recursivos para cualquier valor de K, situacin opuesta a la de
aplicar Fijar las Hojas. La razn fundamental de que para los algoritmos recursivos
Fijar las Hojas sea siempre mejor que Fijar la Raz es, porque segn el recorrido
(sincronizado en profundidad) que emplean, cuanto ms tarden en llegar a las hojas,
ms tarda ser la actualizacin de distanciaPodaKCPC (nmero de accesos a disco,
tiempo de respuestas, etc.). En cambio, para los algoritmos que utilizan un montculo
global con una funcin de seleccin de primero el mejor, cuantos ms pares de MBRs
se combinen en niveles superiores, mejores candidatos habr en el montculo mnimo
global en el momento de procesar las hojas y la actualizacin de distanciaPodaKCPC
ser mejor puesto que se hace a nivel global en funcin de K y MaxMaxDist, por ello,
FR es considerablemente mejor que FH.

1 10 100 1000 10000 100000 1000000
RECU_FH 49759 49836 50203 51324 55236 68660 123002
RECU_FR 75016 75106 75414 76488 80144 91712 134262
HEAP_FH 55468 55590 56122 57908 63886 85722 174442
HEAP_FR 55458 55532 55792 56736 59954 70094 107924
Tabla 6.15 Nmero de accesos a disco para K-CPC sobre R*-trees con diferentes alturas,
aplicando algoritmos recursivos e iterativos en su variante STD.
40000
68000
96000
124000
152000
180000
1 10 100 1000 10000 100000 1000000
Nmero de Pares
A
c
c
e
s
o
s

a

D
i
s
c
o
RECU_STD_FH RECU_STD_FR HEAP_STD_FH HEAP_STD_FR

Figura 6.8 K-CPC para algoritmos recursivos e iterativos (variante STD) sobre R*-trees
con diferentes alturas, utilizando las tcnicas de Fijar las Hojas (FH) y Fijar la Raz (FR).
Captulo 6
198
En la Figura 6.8 se ilustra el comportamiento que tienen los algoritmos recursivos e
iterativos (en su variante STD) sobre R*-trees con diferentes alturas y utilizando las tcnicas
Fijar las Hojas (FH) y Fijar la Raz (FR). La variante recursiva STD, utilizando Fijar las
Hojas, es la mejor alternativa para todos los valores de K, excepto para K = 1000000 que lo es
HEAP_STD empleando Fijar la Raz.

Influencia de aplicar la heurstica de poda basada en MaxMaxDist y el tratamiento de
empates
Para completar el estudio de CPC y K-CPC utilizando R*-trees con diferentes alturas vamos a
ver el efecto de aplicar Fijar las Hojas y Fijar la Raz sobre las variantes del algoritmo
iterativo que utiliza un montculo mnimo global (HEAP) para el nmero de inserciones en el
montculo y el tamao mximo del mismo en nmero de pares de MBRs. Para CPC en las
Tablas 6.16 y 6.17 se comparan los resultados sin considerar y considerando la heurstica de
poda basada en MaxMaxDist y la mejor alternativa de tratamiento de empates sobre pares de
MBRs con el mismo valor de MinMinDist. Al igual que comprobamos en la seccin anterior,
considerar estas tcnicas de optimizacin suponen un gran ahorro para estos dos parmetros
(tamao mximo y nmero de inserciones de/en montculo global).

SIN CONSIDERAR OPTIMIZACIN CONSIDERANDO OPTIMIZACIN
HEAP_FH HEAP_FR HEAP_FH HEAP_FR
EXH 7734 11748 473 622
SIM 921 1588 239 281
STD 1798 2321 239 281
STM 1228 1380 239 281
PS 1028 1540 239 281
Tabla 6.16 Tamao mximo del montculo para CPC utilizando el algoritmo iterativo HEAP,
considerando y sin considerar tcnicas de optimizacin.

SIN CONSIDERAR OPTIMIZACIN CONSIDERANDO OPTIMIZACIN
HEAP_FH HEAP_FR HEAP_FH HEAP_FR
EXH 44212 36742 37815 28165
SIM 37725 28140 37581 27824
STD 38010 28263 37581 27824
STM 37992 28107 37581 27824
PS 37797 28065 37581 27824
Tabla 6.17 Nmero de inserciones en el montculo para CPC utilizando el algoritmo iterativo
HEAP, considerando y sin considerar tcnicas de optimizacin.
Para el caso de K-CPC, las Tablas 6.18 y 6.19 muestran los resultados en base a estos dos
parmetros en estudio suponiendo que se considera MaxMaxDist y la mejor alternativa de
tratamiento de empates sobre pares de MBRs con el mismo valor de MinMinDist (seleccionar
el par cuyo componente tiene el menor nivel y en caso de empate, el componente del par que
tiene el MBR ms pequeo en funcin de su rea).

Resultados experimentales y aplicacin
199
1 10 100 1000 10000 100000
FH FR FH FR FH FR FH FR FH FR FH FR
EXH 7734 11748 8879 12015 9703 12787 15032 17442 25294 29050 46579 72088
34.17% 26.10% 24.12% 13.82% 12.93% 35.39%
SIM 330 441 398 506 685 806 1741 1836 5632 5970 18939 23181
25.17% 21.34% 15.01% 5.17% 5.66% 18.30%
STD 315 380 383 445 668 738 1715 1764 5556 5895 18843 23101
17.11% 13.93% 9.49% 2.78% 5.75% 18.43%
STM 315 380 383 445 668 738 1715 1764 5556 5895 18843 23101
17.11% 13.93% 9.49% 2.78% 5.75% 18.43%
PS 335 452 403 517 690 811 1736 1822 5605 5950 18892 23179
25.88% 22.05% 14.92% 4.72% 5.80% 18.50%
Tabla 6.18 Tamao mximo del montculo para K-CPC empleando el algoritmo iterativo
HEAP, utilizando Fijar las Hojas (FH) y Fijar la Raz (FR).

1 10 100 1000 10000 100000
FH FR FH FR FH FR FH FR FH FR FH FR
EXH 44212 36742 44307 37031 44701 38036 57904 42503 62249 53053 84461 78625
16.90% 16.42% 14.91% 26.60% 14.77% 6.91%
SIM 37672 27984 37760 28056 38068 28375 39175 29430 43228 33595 57276 50921
25.72% 25.70% 25.46% 24.88% 22.28% 11.10%
STD 37657 27923 37745 27995 38051 28307 39149 29358 43152 33520 57180 50841
25.85% 25.83% 25.61% 25.01% 22.32% 11.09%
STM 37657 27923 37745 27995 38051 28307 39149 29358 43152 33520 57180 50841
25.85% 25.83% 25.61% 25.01% 22.32% 11.09%
PS 37677 27995 37765 28067 38073 28380 39170 29416 43201 33575 57229 50919
25.85% 25.83% 25.61% 25.01% 22.32% 11.09%
Tabla 6.19 Nmero de inserciones en montculo para K-CPC empleando el algoritmo
iterativo HEAP, utilizando Fijar las Hojas (FH) y Fijar la Raz (FR).
De las tablas anteriores podemos comprobar que aplicar la tcnica de Fijar la Raz
proporciona un sensible aumento del tamao del montculo principal con respecto a aplicar
Fijar las Hojas. Esto es debido a que el algoritmo debe procesar el R*-tree ms grande hasta
alcanzar la altura del ms pequeo, y cuanto mayor sea la diferencia de altura, mayor ser el
nmero de pares de MBRs insertados en el montculo utilizando la tcnica Fijar la Raz. Por
lo que respecta al nmero de inserciones, ste se ve considerablemente reducido al aplicar
Fijar la Raz, porque esta forma de procesar los R*-trees hace que distanciaPodaKCPC en
base a MaxMaxDist (parMasCercano.distancia en base a MinMaxDist para CPC) tenga un
valor bastante ms pequeo que si se procesan los dos R*-trees fijando las hojas, lo que
provoca una notable reduccin en el nmero de inserciones en el montculo mnimo principal.

Evaluacin del tiempo de respuesta
Por ltimo, el tiempo de respuesta (segundos) para los algoritmos recursivos e iterativos va a
ser el siguiente parmetro a estudio considerando R*-trees con diferentes alturas y utilizando
las dos tcnicas presentadas para su procesamiento (FH y FR).

Captulo 6
200
RECU HEAP
FH FR FH FR
EXH 5.99 5.61 7.32 6.91
SIM 14.65 21.69 16.54 22.50
STD 16.29 24.31 18.22 27.02
STM 16.19 23.74 17.73 23.90
PS 2.30 2.48 4.42 3.61
Tabla 6.20 Tiempo de respuesta en segundos para CPC,
sobre R*-trees con diferentes alturas.
0
6
12
18
24
30
EXH SIM STD STM PS
Alternativas de Algoritmos
T
i
e
m
p
o

d
e

R
e
s
p
u
e
s
t
a

(
s
e
g
.
)
RECU_FH RECU_FR HEAP_FH HEAP_FR

Figura 6.9 Tiempo de respuesta en segundos para CPC, sobre R*-trees con diferentes
alturas.
De la Tabla 6.20, que representamos en la grfica de barras de la Figura 6.9, podemos
extraer varias conclusiones interesantes para CPC:
1. Los algoritmos recursivos son ms rpidos que los iterativos, y la tcnica Fijar las
Hojas es mejor que aplicar Fijar la Raz. La razn de esta diferencia radica
fundamentalmente en la gestin extra que tienen que hacer los algoritmos iterativos
sobre el montculo mnimo global de pares de MBRs.
2. En el algoritmo iterativo, utilizar la tcnica Fijar la Raz, es ms beneficioso que utilizar
Fijar las Hojas para EXH y PS, mientras que para las otras variantes (SIM, STD y
STM) ocurre lo contrario. Esto se debe fundamentalmente al uso que estas ltimas
variantes hacen de MinMaxDist y que para Fijar la Raz combinan ms pares de MBRs
fijando la raz del R*-tree con menor altura, lo que supone un nmero mayor de clculos
de distancias entre MBRs.
3. PS es la variante con menor tiempo de respuesta debido a que el Barrido del Plano es
una tcnica pensada para optimizar este parmetro, ya que no considera la combinacin
de todas las entradas de un nodo con todas las del otro nodo, como hemos podido
comprobar en el apartado 6.2.
Resultados experimentales y aplicacin
201
4. Aplicar MinMaxDist (SIM, STD y STM) y ordenar los pares de MBRs en base a
MinMinDist (STD y STM) requieren un tiempo adicional y hacen que estas variantes
sean las ms lentas, sobre todo si se aplica la tcnica de Fijar la Raz (cuanto mayor es
el nmero de pares de MBRs que se combinan, mayor es el nmero de MinMinDist y
MinMaxDist que se tienen que calcular) en el algoritmo iterativo.
Para K-CPC, obtenemos los resultados (sin considerar MaxMaxDist ni el tratamiento de
empates) que mostramos en la Tabla 6.21, aplicando las dos tcnicas conocidas (FH y FR)
sobre R*-trees con diferentes alturas.

1 10 100 1000 10000 100000 1000000
FH FR FH FR FH FR FH FR FH FR FH FR FH FR
REXH 7.16 7.39 7.22 7.43 7.31 7.53 7.70 8.04 9.98 11.07 25.65 30.57 167.33 174.51
RSIM 7.02 7.39 7.08 7.51 7.14 7.52 7.53 8.06 9.89 11.16 26.20 31.41 173.98 177.92
RSTD 17.89 27.51 17.79 27.74 17.89 27.81 18.28 28.30 20.31 30.51 33.31 43.99 130.69 138.32
RSTM 18.49 26.55 18.54 26.60 18.63 26.71 18.98 27.21 20.86 29.27 33.83 42.75 122.60 135.01
RPS 2.29 2.46 2.34 2.51 2.36 2.66 2.66 3.36 4.25 7.53 18.23 36.78 149.07 280.53
HEXH 9.86 8.84 8.95 8.39 9.04 8.44 9.72 8.73 11.05 10.23 18.64 18.10 62.11 63.58
HSIM 9.02 8.57 9.09 8.62 9.19 8.64 9.86 8.94 11.28 10.54 19.59 19.25 63.93 64.37
HSTD 20.67 27.30 20.94 27.91 21.05 27.97 21.37 28.44 22.72 29.75 31.36 39.48 76.09 84.10
HSTM 19.41 26.33 19.42 26.20 19.57 26.20 19.89 26.64 21.30 28.63 29.58 38.93 73.91 85.10
HPS 4.43 3.57 4.48 3.62 4.55 3.74 4.87 4.09 6.44 5.63 16.08 15.13 60.78 58.86
Tabla 6.21 Tiempo de respuesta en segundos para K-CPC, sobre R*-trees con diferentes
alturas. Donde R = RECU y H = HEAP.
Para ilustrar la tendencia de los algoritmos aplicando las tcnicas para el procesamiento de
rboles con diferentes alturas (FH y FR) respecto al tiempo de respuesta, hemos seleccionado
la mejor variante (PS) tanto para los algoritmos recursivos como para los iterativos, dando
lugar a la Figura 6.10. Como se puede observar en dicha figura, el incremento de tiempo que
sufren los algoritmos recursivos conforme los valores de K se hacen extremadamente grandes
no se aprecia para los iterativos, cuya tendencia es mucho ms suave y no tan pronunciada.
Adems, la mejor alternativa cuando los R*-trees tienen diferentes alturas es: Fijar las Hojas
para los algoritmos recursivos, y Fijar la Raz para los iterativos. El motivo fundamental de
que Fijar las Hojas sea la mejor alternativa para los algoritmos recursivos es porque siguen
un recorrido en profundidad y cuanto antes alcancen los nodos hoja, la actualizacin de
distanciaPodaKCPC y KMasCercanos ser ms efectiva. Por otro lado, Fijar la Raz es la
mejor tcnica para los iterativos, ya que, adems de seguir una estrategia de bsqueda de
primero el mejor sobre un montculo mnimo global para evitar la recursividad, cuantos ms
MBRs se combinen en niveles superiores, la actualizacin de distanciaPodaKCPC ser
mejor, y una vez alcanzado el nivel de las hojas, los mejores pares de objetos sern los
primeros en obtenerse.
Captulo 6
202
0
8
16
24
32
40
1 10 100 1000 10000 100000
Nmero de Pares
T
i
e
m
p
o

d
e

R
e
s
p
u
e
s
t
a

(
s
e
g
.
)
RECU_PS_FH HEAP_PS_FH RECU_PS_FR HEAP_PS_FR

Figura 6.10 Tiempo de respuesta para K-CPC aplicado a las mejores alternativas recursivas e
iterativas.

Conclusiones
La conclusin ms importante que podemos extraer de este conjunto de experimentos y aadir
a las obtenidas en el apartado anterior es que para procesar R*-trees con diferentes alturas,
Fijar las Hojas (FH) es la mejor tcnica para el algoritmo recursivo, mientras que Fijar la
Raz (FR) lo es para los algoritmos iterativos. Adems, la versin recursiva con Fijar las
Hojas (FH) es la que proporciona los mejores resultados (nmero de accesos a disco y tiempo
de respuesta) cuando K < 100000, mientras que cuando K 100000 lo es la versin iterativa
(HEAP) combinado con la tcnica Fijar la Raz (FR).

6.4 Efecto del porcentaje de solape entre los conjuntos de
datos

Un factor muy importante que hay que tener presente para este tipo de consulta basada en
distancias es el efecto que produce el porcentaje de solape entre las reas que cubren los
conjuntos de datos que intervienen en ella. Para realizar los experimentos que muestren el
comportamiento de los algoritmos ante este parmetro hemos utilizado conjuntos de datos
(puntos) de diferente naturaleza. Por un lado, puntos reales y reales movidos aleatoriamente, y
por otro, sintticos siguiendo una distribucin uniforme y generados aleatoriamente. Todos
ellos tienen idntica cardinalidad (62556 puntos), dando lugar a R*-trees con la misma altura
(4).
Para generar conjuntos de datos (puntos) con diferente porcentaje de solape entre las reas
que los cubren, hemos considerado los dos conjuntos de objetos en el mismo espacio (100%),
Resultados experimentales y aplicacin
203
y moviendo el segundo de ellos sobre las dos dimensiones (X e Y) de manera que el
porcentaje de solape de las reas que cubren cada uno era del 75%, 50%, 25%, 12%, 6%, 3%
y 0%.

Evaluacin del nmero de accesos a disco
En primer lugar, mostramos los resultados de CPC, para el algoritmo recursivo (RECU) e
iterativo (HEAP), con respecto al nmero de accesos a disco. La Tabla 6.22 representa dicha
informacin para datos reales y reales movidos aleatoriamente, mientras que la Tabla 6.23 y
Figura 6.11 muestran las operaciones de E/S obtenidas de aplicar los algoritmos sobre
conjuntos de datos sintticos obtenidos segn una distribucin uniforme y generados
aleatoriamente.

0% 3% 6% 12% 25% 50% 75% 100%
RECU_EXH 376 380 378 392 378 1714 17356 37868
RECU_SIM 58 84 88 98 92 1540 17348 37846
RECU_STD 74 70 80 92 18 1428 17294 37838
RECU_STM 74 70 80 92 18 1428 17264 37838
RECU_PS 812 802 794 758 658 1762 17382 37880
HEAP_EXH 26 30 32 32 18 1428 17192 37830
HEAP_SIM 26 30 32 32 18 1428 17192 37830
HEAP_STD 26 30 32 32 18 1428 17192 37830
HEAP_STM 26 30 32 32 18 1428 17192 37830
HEAP_PS 26 30 32 32 18 1428 17192 37830
Tabla 6.22 Nmero de accesos a disco para CPC sobre R*-trees procedentes de la
indexacin de puntos reales y reales movidos aleatoriamente.

0% 3% 6% 12% 25% 50% 75% 100%
RECU_EXH 270 1138 1962 3786 8020 16996 25372 33196
RECU_SIM 86 958 1800 3636 7898 16918 25324 33194
RECU_STD 74 940 1768 3608 7852 16900 25324 33192
RECU_STM 74 942 1764 3604 7856 16910 25340 33186
RECU_PS 788 1612 2432 4274 8422 17278 25500 33196
HEAP_EXH 66 934 1764 3588 7830 16874 25320 33164
HEAP_SIM 66 934 1764 3588 7830 16874 25320 33164
HEAP_STD 66 934 1764 3588 7830 16874 25320 33164
HEAP_STM 66 934 1764 3588 7830 16874 25320 33164
HEAP_PS 66 934 1764 3588 7830 16874 25320 33164
Tabla 6.23 Nmero de accesos a disco para CPC, utilizando R*-trees procedentes de la
indexacin de puntos sintticos generados aleatoriamente y siguiendo una distribucin
uniforme.
Captulo 6
204
0
5000
10000
15000
20000
25000
30000
35000
0% 3% 6% 12% 25% 50% 75% 100%
Porcentaje de Solape
A
c
c
e
s
o
s

a

D
i
s
c
o
RECU_SIM RECU_STD RECU_PS HEAP_EXH

Figura 6.11 Nmero de accesos a disco para CPC para algoritmos recursivos e iterativos con
puntos aleatorio/uniforme.
Las conclusiones ms importantes que podemos extraer de la Figura 6.11 y de los datos de
las tablas anteriores son las siguientes:
1. Cuando crece el factor de solape entre las reas que cubren los conjuntos de objetos, el
nmero de accesos a disco tambin crece. La razn de este crecimiento es debida
fundamentalmente a que, cuanto mayor es el porcentaje de solape entre los conjuntos de
objetos (rea que los cubren), mayor ser el nmero valores de distancia MinMinDist
entre MBRs igual a 0 o muy prxima a l. Esto provocar un incremento en el nmero
de llamadas recursivas y en el nmero de pares de MBRs que se insertan en el
montculo mnimo principal para los algoritmos recursivos e iterativos, respectivamente.
2. Las variantes del algoritmo iterativo encuentran la solucin en un nmero menor de
accesos a disco (todos igual) que las variantes del algoritmo recursivo, debido
fundamentalmente a la propia naturaleza de los mismos y a la estrategia de bsqueda
que utilizan.
3. Del algoritmo recursivo, las versiones STD y STM son las que tienen un menor nmero
de accesos a disco, aunque cuando tenemos el 100% de porcentaje de solape entre las
reas que cubren los conjuntos de datos (puntos), todos tienen un comportamiento muy
similar (incluso PS, que cuando el porcentaje es pequeo, proporciona los peores
resultados). La razn de este mejor comportamiento es debido a la ordenacin que se
establece en funcin de MinMinDist entre pares de MBRs antes de realizar la llamada
recursiva.
Sobre los mismos conjuntos de datos indexados en sendos R*-trees para K-CPC podemos
estudiar el coste relativo que tiene un algoritmo respecto a otro tomado como referencia segn
el nmero de accesos a disco cuando se aumenta el porcentaje de solape entre las reas que
cubren los conjuntos de datos que intervienen en la consulta. El nmero de accesos a disco
para RECU_EXH lo tomamos como referencia y representamos el coste de los otros
algoritmos relativo al incremento de K y del porcentaje de solape. Tambin debemos destacar
Resultados experimentales y aplicacin
205
que el coste relativo de la variantes STD y STM del algoritmo recursivo son prcticamente
idnticos, puesto que ambos ordenan los pares de MBRs en base a MinMinDist (lista y
montculo mnimo local, respectivamente), y por ello slo vamos a considerar la alternativa
STD.

0%
3%
6%
12%
25%
50%
75%
100%
1
100
10000
1000000
85%
88%
91%
94%
97%
100%
C
o
s
t
e

R
e
la
t
iv
o
Porcentaje de Solape
# Pares
85%-88% 88%-91% 91%-94% 94%-97% 97%-100%

0%
3%
6%
12%
25%
50%
75%
100%
1
100
10000
1000000
0%
20%
40%
60%
80%
100%
C
o
s
t
e

R
e
la
t
iv
o
Porcentaje de Solape
# Pares
0%-20% 20%-40% 40%-60% 60%-80% 80%-100%

RECU_SIM RECU_STD
0%
3%
6%
12%
25%
50%
75%
100%
1
100
10000
1000000
90%
112%
134%
156%
178%
200%
C
o
s
t
e

R
e
la
t
iv
o
Porcentaje de Solape
# Pares
90%-112% 112%-134% 134%-156% 156%-178% 178%-200%

0%
3%
6%
12%
25%
50%
75%
100%
1
100
10000
1000000
0%
20%
40%
60%
80%
100%
C
o
s
t
e

R
e
la
t
iv
o
Porcentaje de Solape
# Pares
0%-20% 20%-40% 40%-60% 60%-80% 80%-100%

RECU_PS HEAP
Figura 6.12 Coste relativo de K-CPC para los algoritmos recursivos (RECU_SIM,
RECU_STD y RECU_PS) e iterativo (HEAP) tomando como referencia RECU_EXH
respecto al incremento de K y del porcentaje de solape entre las reas que cubren los
conjuntos de datos (puntos reales combinados con reales movidos aleatoriamente) con la
misma cardinalidad.
De la Figura 6.12, podemos extraer las siguientes conclusiones:
1. La variante recursiva RECU_SIM, cuando el porcentaje de solape es menor del 50% y
K 10000, tiene un coste sobre el 10% menor que RECU_EXH, pero en los otros casos
(porcentaje de solape mayor al 50% y K > 10000) el coste es muy similar al de
RECU_EXH. Esto es debido a que conforme crece el porcentaje de solape y K se hace
ms grande, la influencia de MaxMaxDist para K-CPC deja de tener efecto.
Captulo 6
206
2. RECU_STD es la versin recursiva que proporciona una mejora importante cuando el
porcentaje de solape es menor del 50%, teniendo un coste del 80% al 95% menor que
RECU_EXH para cualquier valor de K. Cuando el porcentaje de solape de las reas que
cubren los conjuntos de datos es superior al 50% tiene un coste similar a RECU_EXH
cuando K es menor o igual a 100000. Interesante resulta el coste para K = 1000000, que
es de un 80% y 85% respecto de RECU_EXH cuando el porcentaje de solape es del
75% y 100%, respectivamente. Esto quiere decir que ordenar los pares de MBRs segn
MinMinDist supone un ahorro considerable cuando el porcentaje de solape es pequeo,
para cualquier valor de K. Adems, cuando el factor de solape y K son grandes, tambin
se produce un ahorro importante en el nmero de accesos a disco.
3. En lo que respecta a la variante PS del algoritmo recursivo (RECU_PS), sta est
pensada fundamentalmente para optimizar el tiempo de respuesta, aunque este ahorro en
tiempo puede suponer un incremento en el nmero de accesos a disco en algunos casos.
Este fenmeno se puede apreciar cuando las reas que cubren los conjuntos de datos
tienen un porcentaje de solape inferior al 75%, siendo K 10000. En cambio, cuando el
porcentaje de solape est prximo al 100% y para cualquier valor de K, la consulta
utilizando RECU_PS tiene un coste en nmero de accesos a disco muy parecido a
RECU_EXH. El motivo de que porcentajes de solape bajos o nulos provoquen un
nmero de accesos a disco para RECU_PS de aproximadamente el doble de
RECU_EXH es porque aplicar la tcnica de Barrido del Plano puede hacer que muchos
nodos hoja se visiten ms de una vez, ya que el pivote puede ser de un R*-tree (R
P
) o
del otro (R
Q
) dependiendo del orden de los MBRs en el eje de barrido, mientras que con
RECU_EXH el pivote es siempre del primer R*-tree (R
P
), lo que provoca una mejor
actualizacin de la distancia del par de objetos situado en la raz del montculo mximo
KMasCercanos.
4. Cualquiera de las alternativas del algoritmo iterativo (HEAP) tiene un coste del 90%-
95% menor que RECU_EXH para cualquier valor de K y porcentaje de solape pequeo
(incluso menor coste que STD como mejor alternativa recursiva). El coste de este
algoritmo se incrementa conforme aumenta el factor de solape (llegando a ser
prcticamente igual cuando K 1000), aunque ese aumento es menor cuando K es muy
grande. Especial atencin merece el caso en que las reas que cubren los conjuntos
estn totalmente solapados y K = 1000000, puesto que el coste de HEAP es del 52%
con respecto a RECU_EXH. La razn de este mejor comportamiento del algoritmo
iterativo con respecto a las variantes recursivas es fundamentalmente por la naturaleza
del mismo, ya que la versin iterativa que utiliza un montculo mnimo global siempre
obtiene el mejor par de MBRs (menor MinMinDist) a procesar, generando siempre, en
su etapa final, los mejores pares de objetos candidatos.
En [CMT
+
00a, CMT
+
00b] se presenta un estudio similar entre conjuntos de puntos,
siguiendo una distribucin uniforme y el mismo conjunto de puntos reales. El
comportamiento de los algoritmos es muy similar al mostrado anteriormente, y las diferencias
que aparecen se deben fundamentalmente a la utilizacin de un path-buffer, elemento que,
como comprobaremos posteriormente, beneficia en mayor medida a las variantes del
algoritmo recursivo.

Resultados experimentales y aplicacin
207
Evaluacin del tiempo de respuesta
El tiempo de respuesta (segundos) para los algoritmos recursivos e iterativos va a ser el
siguiente parmetro a estudio, considerando los mismos porcentajes de solape entre las reas
que cubren los conjuntos de datos (puntos) reales y reales movidos aleatoriamente con la
misma cardinalidad (62556), dando lugar a R*-trees con la misma altura (4).

0% 3% 6% 12% 25% 50% 75% 100%
RECU_EXH 0.20 0.10 0.05 0.07 0.06 0.45 2.32 4.47
RECU_SIM 0.11 0.16 0.16 0.18 0.18 0.98 7.40 14.92
RECU_STD 0.25 0.22 0.27 0.21 0.04 0.93 8.31 16.65
RECU_STM 0.21 0.20 0.24 0.20 0.04 0.92 8.26 16.63
RECU_PS 0.17 0.06 0.08 0.10 0.10 0.29 0.79 1.67
HEAP_EXH 0.05 0.04 0.05 0.05 0.05 0.23 2.32 4.70
HEAP_SIM 0.05 0.07 0.07 0.06 0.04 0.87 7.80 15.75
HEAP_STD 0.07 0.08 0.07 0.08 0.05 0.97 8.61 17.38
HEAP_STM 0.06 0.07 0.07 0.07 0.04 0.93 8.26 16.66
HEAP_PS 0.04 0.04 0.04 0.04 0.05 0.22 1.21 2.49
Tabla 6.24 Tiempo de respuesta en segundos para CPC, sobre R*-trees procedentes de la
indexacin de puntos reales y reales movidos aleatoriamente.
De la Tabla 6.24 podemos extraer algunas conclusiones interesantes para CPC en lo que
respecta al tiempo global de respuesta de dicha consulta:
1. Al igual que vimos en apartados anteriores la variante PS (Plane-Sweep) es la ms
rpida tanto para el algoritmo recursivo como para el iterativo, ya que est diseada
para obtener los mejores resultados en lo que respecta al tiempo total de respuesta
requerido.
2. Si de la Tabla 6.24 extraemos los resultados de los dos algoritmos para PS (recursivo e
iterativo), obtenemos la Figura 6.13, de la cual podemos observar claramente que la
variante iterativa tiene un mejor comportamiento que la recursiva cuando el porcentaje
de solape es bajo (menor al 75%). Los papeles se invierten cuando el porcentaje de
solape se hace mayor, siendo PS aplicado al algoritmo recursivo la ms rpida. Este
ltimo fenmeno se debe fundamentalmente a dos factores: el primero es porque slo
tenemos que calcular el par ms cercano y para ello la versin recursiva siguiendo un
recorrido en profundidad es mejor que utilizar un recorrido basado en una estrategia de
bsqueda de primero el mejor utilizando un montculo mnimo, y el segundo es porque,
cuanto ms porcentaje de solape haya entre las reas que cubren los conjuntos de datos,
mayor ser el nmero de pares de MBRs con MinMinDist igual o muy prximos a 0,
que tendrn que almacenarse en el montculo mnimo principal para procesarlos
posteriormente.
3. Al igual que pudimos comprobar en apartados anteriores, las variantes de los algoritmos
que hacen uso de MinMaxDist y ordenan los pares de MBRs en funcin de su
MinMinDist tardan ms tiempo en obtener la respuesta a la consulta, ya que realizar
dichos clculos y operaciones asociadas requieren un tiempo adicional, aunque
beneficien el rendimiento respecto a otros parmetros como puede ser al nmero de
accesos a disco.
Captulo 6
208
0
0.5
1
1.5
2
2.5
0% 3% 6% 12% 25% 50% 75% 100%
Porcentaje de Solape
T
i
e
m
p
o

d
e

R
e
s
p
u
e
s
t
a

(
s
e
g
.
)
RECU_PS HEAP_PS

Figura 6.13 Tiempo de respuesta en segundos para CPC sobre los algoritmos recursivos e
iterativos en su variante PS, sobre R*-trees procedentes de la indexacin de puntos reales y
reales movidos aleatoriamente.
Para K-CPC obtenemos los siguientes resultados (sin considerar MaxMaxDist ni
tratamiento de empates) teniendo en cuenta los diferentes porcentajes de solape entre las reas
que cubren los conjuntos de datos. Las siete tablas siguientes (Tabla 25) muestran el tiempo
de respuesta de las variantes ms representativas (EXH y SIM tienen valores muy prximos,
al igual que sucede a STD y STM. Por este motivo slo hemos escogido las primeras) del
algoritmo recursivo y del iterativo para los diferentes valores de K.

K = 1 0% 3% 6% 12% 25% 50% 75% 100%
RECU_EXH 0.08 0.10 0.07 0.07 0.06 0.45 2.79 5.45
RECU_STD 0.22 0.22 0.25 0.21 0.05 0.94 8.51 17.25
RECU_PS 0.16 0.08 0.11 0.10 0.08 0.09 0.76 1.67
HEAP_EXH 0.05 0.04 0.05 0.04 0.04 0.25 2.81 5.82
HEAP_STD 0.12 0.12 0.12 0.11 0.08 1.14 9.69 19.46
HEAP_PS 0.04 0.04 0.05 0.04 0.04 0.22 1.20 2.46

K = 10 0% 3% 6% 12% 25% 50% 75% 100%
RECU_EXH 0.08 0.09 0.12 0.08 0.08 0.25 2.36 5.05
RECU_STD 0.23 0.23 0.30 0.24 0.07 0.97 8.78 17.63
RECU_PS 0.13 0.16 0.13 0.12 0.12 0.11 0.78 1.68
HEAP_EXH 0.04 0.04 0.04 0.04 0.04 0.26 2.82 5.83
HEAP_STD 0.12 0.12 0.13 0.11 0.07 1.12 9.54 19.14
HEAP_PS 0.04 0.04 0.04 0.04 0.05 0.22 1.23 2.49

K = 100 0% 3% 6% 12% 25% 50% 75% 100%
RECU_EXH 0.16 0.16 0.16 0.15 0.17 0.31 2.45 5.08
RECU_STD 0.32 0.29 0.38 0.36 0.05 1.02 8.93 17.72
RECU_PS 0.36 0.35 0.32 0.31 0.26 0.23 0.86 1.75
HEAP_EXH 0.05 0.05 0.04 0.05 0.04 0.27 2.85 5.85
HEAP_STD 0.16 0.15 0.14 0.14 0.09 1.15 9.61 19.2
HEAP_PS 0.05 0.04 0.05 0.04 0.04 0.24 1.32 2.62
Resultados experimentales y aplicacin
209

K = 1000 0% 3% 6% 12% 25% 50% 75% 100%
RECU_EXH 0.62 0.63 0.61 0.56 0.55 0.70 2.66 5.43
RECU_STD 0.50 0.47 0.71 0.64 0.14 1.16 9.37 18.11
RECU_PS 1.25 1.23 1.21 1.17 1.26 0.84 1.32 2.01
HEAP_EXH 0.06 0.07 0.07 0.05 0.06 0.40 3.01 6.07
HEAP_STD 0.19 0.18 0.18 0.19 0.19 1.23 9.90 19.57
HEAP_PS 0.06 0.06 0.06 0.05 0.06 0.31 1.59 3.24

K = 10000 0% 3% 6% 12% 25% 50% 75% 100%
RECU_EXH 4.03 4.12 4.28 4.36 3.73 3.38 4.90 7.27
RECU_STD 1.27 1.24 1.51 1.30 0.46 1.93 11.05 19.38
RECU_PS 7.76 7.66 7.64 7.67 7.03 5.75 4.42 3.46
HEAP_EXH 0.39 0.24 0.24 0.27 0.25 0.81 3.92 7.50
HEAP_STD 0.50 0.59 0.48 0.52 0.46 2.06 11.41 21.24
HEAP_PS 0.24 0.23 0.24 0.26 0.23 0.74 2.67 4.77

K = 100000 0% 3% 6% 12% 25% 50% 75% 100%
RECU_EXH 34.19 35.02 34.60 34.41 32.52 29.84 22.95 21.22
RECU_STD 9.63 9.76 9.78 9.58 3.57 8.65 24.55 31.52
RECU_PS 55.22 54.50 52.59 52.09 50.89 44.40 27.94 15.64
HEAP_EXH 1.41 1.38 1.37 1.37 1.27 2.86 10.32 15.42
HEAP_STD 1.96 1.91 1.09 2.57 3.28 4.08 18.79 29.34
HEAP_PS 1.94 1.40 1.39 2.43 2.30 3.08 9.06 13.36

K=1000000 0% 3% 6% 12% 25% 50% 75% 100%
RECU_EXH 259.93 257.09 254.89 248.88 239.09 209.83 168.88 130.55
RECU_STD 60.66 61.94 64.16 65.66 39.84 59.04 126.14 109.58
RECU_PS 381.79 376.89 376.53 370.40 356.89 321.38 205.62 129.50
HEAP_EXH 9.42 9.47 9.39 9.25 9.63 12.87 34.04 50.68
HEAP_STD 11.92 12.65 12.81 12.37 12.39 15.73 43.03 66.72
HEAP_PS 11.37 11.04 10.90 10.21 10.01 13.24 30.31 49.97
Tabla 6.25 Tiempo de respuesta en segundos para K-CPC utilizando los algoritmos
recursivos e iterativos, sobre R*-trees procedentes de la indexacin de puntos reales y reales
movidos aleatoriamente con diferente porcentaje de solape.
De las tablas anteriores (Tabla 6.25) podemos extraer conclusiones interesantes como:
1. Siempre que el porcentaje de solape sea inferior al 75%, el algoritmo iterativo
proporciona mejores resultados que el recursivo, para cualquier valor de K.
Concretamente, HEAP_PS es la mejor alternativa cuando K 10000 y HEAP_EXH lo
es cuando K 100000. Tal y como hemos explicado en epgrafes anteriores, RECU_PS
deja de ser la variante ganadora cuando K se hace muy grande.
2. Los casos en que las reas que cubren los conjuntos de datos estn muy solapadas
(porcentaje de solape mayor o igual al 75%) la variante recursiva RECU_PS es la mejor
alternativa cuando K 10000, pero cuando K 100000 los menores tiempos de
respuesta son para la variante PS del algoritmo iterativo, HEAP_PS.
Captulo 6
210
3. Como acabamos de decir, PS es la variante del algoritmo iterativo (HEAP_PS) que
proporciona los mejores tiempos de respuesta cuando K 10000, para cualquier
porcentaje de solape entre las reas que cubren los conjuntos de datos. Este mismo
comportamiento se mantiene cuando K es muy grande y el porcentaje de solape tambin
lo es (mayor al 75%), pero cuando el porcentaje de solape es pequeo para estos
mismos valores de K, la variante ganadora es RECU_EXH. Esto es debido a la poltica
de combinacin de nodos que utiliza cada alternativa. La tcnica de Barrido del Plano
(el pivote vara de un R*-tree a otro segn el orden de los MBRS en los nodos internos
que intervienen en la combinacin) tiene su mayor efecto sobre conjuntos de datos con
alto porcentaje de solape de las reas que los cubren, mientras que la combinacin de
todos con todos (el pivote es siempre del primer R*-tree) es mejor cuando ste es
pequeo.
4. Los algoritmos recursivos, cuando K es muy grande (K 100000), requieren mucho
tiempo para el procesamiento de la consulta, sobre todo las alternativas que no ordenan
los pares de MBRs segn su MinMinDist. Para este caso (K 100000), un resultado
realmente interesante aparece en los algoritmos recursivos que no hacen uso de la
ordenacin de pares de MBRs (RECU_EXH y RECU_PS). ste es que conforme
aumenta el porcentaje de solape el tiempo de respuesta va disminuyendo (opuesto al
comportamiento del algoritmo iterativo y del recursivo cuando K < 100000). Esto se
debe a que cuanto mayor es K y el porcentaje de solape es ms pequeo (la probabilidad
de que todos los valores de MinMinDist sean diferentes de 0 es muy alta), entonces son
necesarias muchas llamadas recursivas para que al final queden en KMasCercanos los K
pares con menor valor de distancia.
5. Continuando con los algoritmos recursivos, RECU_PS es la mejor alternativa cuando K
10000 y el porcentaje de solape es grande (mayor o igual al 50%), pero cuando K >
10000 y tenemos cualquier porcentaje de solape, RECU_STD proporciona los tiempos
de respuesta menores. La razn fundamental de que se produzca este comportamiento
para RECU_STD es porque la ordenacin de pares de MBRs segn su MinMinDist
detecta ms rpidamente los pares con menor distancia, haciendo que el nmero de
llamadas recursivas y actualizaciones del montculo mximo adicional KMasCercanos
sea menor. Adems, en los casos en que K 100 y el porcentaje de solape es pequeo,
RECU_EXH proporciona resultados muy similares a RECU_PS y en algunos casos
incluso mejores.
Para ilustrar las tendencias de los algoritmos ante diferentes porcentajes de solape entre las
reas que cubren los conjuntos de datos se muestra la Figura 6.14, que representa el tiempo de
respuesta (segundos) de las variantes ms representativas de los algoritmos, siendo K igual a
10 y 1000000.

Resultados experimentales y aplicacin
211
0
5
10
15
20
0% 3% 6% 12% 25% 50% 75% 100%
Porcentaje de Solape
T
i
e
m
p
o

d
e

R
e
s
p
u
e
s
t
a

(
s
e
g
.
)
REXH RSTD RPS HEXH HSTD HPS

0
80
160
240
320
400
0% 3% 6% 12% 25% 50% 75% 100%
Porcentaje de Solape
T
i
e
m
p
o

d
e

R
e
s
p
u
e
s
t
a

(
s
e
g
.
)
REXH RSTD RPS HEXH HSTD HPS

Figura 6.14 Tiempo de respuesta para K-CPC (K = 10 y K = 1000000) aplicado a
las mejores alternativas recursivas e iterativas respecto al incremento del
porcentaje de solape entre las reas que cubren los conjuntos de datos. Donde R =
RECU y H = HEAP.
En la primera grfica de la Figura 6.14 (K = 10, como ejemplo de una valor pequeo de K)
podemos apreciar que las versiones iterativas son siempre sensiblemente mejores que sus
homnimas del algoritmo recursivo cuando el porcentaje de solape es menor del 50%,
aunque, cuando dicho porcentaje es mayor o igual al 50%, las variantes recursivas son ms
rpidas. La tendencia general para este valor de K (10) es que conforme crece el porcentaje de
solape, el coste en tiempo de respuesta tambin crece. Por otro lado, en la segunda grfica (K
= 1000000, ejemplo de valor muy grande de K), de forma general, el algoritmo iterativo es
siempre notablemente ms rpido que el recursivo. La tendencia de las variantes del algoritmo
iterativo es que conforme crece el porcentaje de solape entre las reas que cubren los
conjuntos de datos, es ms costosa la consulta desde el punto de vista del tiempo de respuesta.
Dicha tendencia tambin se cumple en cierta manera para la variante STD del algoritmo
recursivo (RSTD = RECU_STD), pero para REXH (RECU_EXH) y RPS (RECU_PS) la
tendencia es completamente la contraria: conforme crece el porcentaje de solape, el tiempo de
respuesta es menor. Este fenmeno se debe fundamentalmente al gran nmero de llamadas
recursivas y actualizaciones de KMasCercanos que tiene que hacer el algoritmo recursivo
Captulo 6
212
cuando no se ordenan los pares de MBRs en funcin de su MinMinDist (hay que explorar uno
a uno todos los posibles pares de MBRs generados de la combinacin de los elementos de dos
nodos internos).

Conclusiones
Las conclusiones ms importantes que podemos extraer de este conjunto de experimentos y
aadir a las obtenidas en los apartados anteriores son las siguientes:
1. Cuando crece el factor de solape entre las reas que cubren los conjuntos de objetos que
intervienen en la consulta, tanto para CPC como para K-CPC, el nmero de accesos a
disco tambin crece, siendo el algoritmo iterativo (las versiones STD y STM del
algoritmo recursivo tuvieron resultados muy prximos) el que proporciona un nmero
menor de operaciones de E/S sin considerar un buffer adicional.
2. En lo que respecta al tiempo de respuesta de la consulta, para CPC, la variante PS del
algoritmo recursivo (RECU_PS) es la ms rpida, al igual que ocurre con K-CPC
cuando K 10000 y el porcentaje de solape es grande. Para el mismo porcentaje de
solape (mayor del 75%) y K 100000, el algoritmo con el menor tiempo requerido para
obtener la respuesta deseada es HEAP_PS (algoritmo iterativo en su variante PS). Por
otro lado, cuando el porcentaje de solape es inferior al 75% y para cualquier valor de K,
HEAP_EXH y HEAP_PS son las alternativas ms rpidas.

6.5 Inclusin de un buffer de pginas con una poltica de
reemplazo LRU

Leer datos directamente desde disco es ms costoso que leerlos de un buffer de pginas
almacenado en memoria principal. Por esta razn, una gestin adecuada de dicho buffer puede
mejorar notablemente el rendimiento del sistema respecto al nmero de accesos a disco. Hasta
el momento se han publicado muchos trabajos sobre la gestin de un buffer de pginas en un
SGBD, donde se adaptan polticas de reemplazo utilizadas en sistemas operativos
dependiendo de la disponibilidad de pginas en el buffer en tiempo de ejecucin, entre ellos
destaca [EfH84]. Por otro lado, otros estudios sobre la gestin del buffer estn enfocados
exclusivamente en patrones de acceso a consultas, siendo las contribuciones ms importantes
[ChD85, SaS82].

Buffers y polticas de reemplazo de pgina
En sistemas de bases de datos reales se utilizan los ndices para acelerar el procesamiento de
una consulta y parte de ese ndice puede estar almacenado en un buffer en memoria principal,
pudiendo mejorar el rendimiento global del sistema de forma notable. Por esta razn, el efecto
Resultados experimentales y aplicacin
213
de incluir un buffer de pginas debe considerarse como un factor importante a la hora de
estudiar el procesamiento de consultas. En la Figura 6.15 se ilustra la arquitectura estndar de
una base de datos para el procesamiento de consultas, donde BD es un conjunto de archivos
binarios (almacenados en disco) divididos en pginas cuyos tamaos se establecen segn
determinados criterios en la creacin de la base de datos (R*-trees R
P
y R
Q
), el Mdulo de E/S
se dedica a leer (escribir) pginas del (al) disco, el Gestor del Buffer trae (lleva) pginas
almacenas en el Buffer Pool del (al) disco a travs del Mdulo de E/S, y el Procesador de
Consultas soporta diferentes tipos de consultas sobre la Base de Datos.

Procesador
de Consultas
Gestor del Buffer
Buffer Pool
Mdulo
de E/S
BD

Figura 6.15 Arquitectura estndar de una base de datos para el procesamiento de
consultas.
El objetivo principal de esta seccin es determinar el efecto de incluir un buffer de pginas
gestionado con una poltica de reemplazo de pgina como es LRU (Least Recently Used) para
la consulta de los pares ms cercanos donde los dos conjuntos de objetos espaciales estn
almacenados en sendos R*-trees.
Han sido muchas las contribuciones publicadas sobre el procesamiento de consultas
espaciales utilizando R-trees que incorporan un buffer de pginas adicional para optimizar el
nmero de accesos a disco. En [BKS93a] se presenta un algoritmo para calcular el join
espacial entre dos R-trees bajo el predicado espacial solapa, utilizando el buffer LRU del
sistema operativo y un buffer adicional denominado path-buffer, donde estn almacenados los
nodos del camino actual en el recorrido de cada R-tree. En [HJR97a] se presenta un join
espacial basado en un recorrido en anchura, donde se utiliza un buffer LRU para la
optimizacin global de la estructura intermedia del join de ndices. En [HjS98] se implementa
un join basado en distancias utilizando un algoritmo incremental, teniendo un buffer LRU
global a los dos R-trees. En [PRS99] se realiza una evaluacin de diferentes estrategias para
realizar joins espaciales. En este caso, el gestor del buffer puede manejar varios buffers de
pginas segn una poltica LRU o FIFO, teniendo en cuenta que un archivo de datos o ndice
tiene asociado un solo buffer pero un buffer puede contener pginas de varios ndices o
archivos de datos. Tambin debemos indicar que en [CVM99] se desarrolla un join espacial
entre dos estructuras de ndices espaciales diferentes, R-tree y un Quadtree de regiones lineal
(Linear Region Quadtree) almacenado en un B
+
-tree [Com79], existiendo, adems de un path-
buffer por cada rbol, un buffer local para cada uno de los ndices gestionado con una poltica
de reemplazo LRU y un FD-buffer que contiene los cdigos FD del Quadtree necesarios para
el procesamiento de la parte actual del R-tree.
La estructura de buffer que vamos a estudiar consiste en dos componentes: el buffer del
sistema y un gestor de un buffer de pginas almacenado en memoria principal. El buffer del
sistema est controlado por el sistema operativo bajo una poltica LRU y ste no es
desactivado. Por otro lado, tenemos el gestor de un buffer de pginas local a cada R*-tree
manipulado segn una poltica de reemplazo LRU y con un nmero de pginas determinado.
Captulo 6
214
Los algoritmos de reemplazo de pgina ms representativos son los siguientes. El
algoritmo FIFO asigna prioridad a las pginas del buffer ms jvenes, reemplazando siempre
la ms antigua. El esquema LFU favorece las pginas ms frecuentemente referenciadas y
sustituye la pgina con frecuencia de acceso ms baja. Gclock es una modificacin de LFU
que funciona de la siguiente forma: cuando ocurre una falta de pgina, reduce cclicamente en
1 el contador de referencias de cada pgina del buffer hasta que alguna llegue a un valor de 0,
y entonces reemplaza la primera que tiene dicho contador a 0. LRU da prioridad a las pginas
ms recientemente referenciadas, sustituyendo la menos recientemente utilizada. MRU es un
esquema opuesto a LRU, sustituyendo la pgina ms recientemente referenciada. El esquema
LRU/2 es un caso particular del algoritmo LRU/K [OOW93], y reemplaza la pgina cuyo
penltimo acceso es el menos recientemente referenciado entre todos los penltimos accesos.
LRD [EfH84] no es una poltica de reemplazo basada en la permanencia de una pgina en el
buffer, sino en su densidad de referencia desde la primera vez que fue accedida, sustituyendo
la pgina con menor densidad de referencia cuando se produce una falta de pgina. En
[PaM96] se propuso una poltica de reemplazo de pgina para bases de datos espaciales,
denominada LRD-Manhattan, y que es una variante de LRD. En dicho algoritmo, cada pgina
del buffer tiene asociado un MBR en el espacio Eucldeo 2-dimensional, cuando ocurre una
falta de pgina, ste utiliza dos parmetros (densidad de referencia de pgina [EfH84] y el
rea del MBR vinculado a dicha pgina) para reemplazar la pgina del buffer con la mnima
probabilidad de referencia.
Existen tambin esquemas de reemplazamiento de pgina hbridos que combinan dos
polticas sencillas para gestionar la permanencia de pginas en el buffer. Estos esquemas
consisten en dividir el buffer en dos regiones, un rea para pginas fras que slo se han
referenciado una vez y otra rea para pginas calientes con ms de un acceso. Por ejemplo, en
[BJK
+
97] la zona de pginas fras se gestiona con una poltica LRU, mientras que la parte de
pginas calientes es tratada como FIFO. Sabiendo que cuando una pgina es re-referenciada
y est en el rea de pginas fras (LRU) pasa al rea de pginas calientes (FIFO). Otra poltica
hbrida, denominada 2Q [JoS94], gestiona el rea de pginas fras como una cola FIFO y la de
calientes como LRU.

Esquema de buffer Local
En esta seccin experimental vamos a considerar uno de los casos propuestos en [CoS00,
CVM01], donde el buffer de pginas tiene un tamao B, est gestionado por un algoritmo de
reemplazo de pgina LRU y sigue un esquema de buffer Local, en el que a cada R*-tree le
vamos a asignar un nmero de pginas igual a B/2. En la Figura 6.16 podemos observar dicho
esquema respecto a las consultas de los pares ms cercanos (CPC y K-CPC). En esta grfica
R
P
y R
Q
son los dos R*-trees almacenados en disco y divididos en pginas cuyos tamaos se
establecen segn determinados criterios en la creacin de los mismos; el Mdulo de E/S se
dedica en este caso a leer pginas del disco y no tenemos control sobre l; el Gestor del
Buffer, siguiendo una poltica de reemplazo de pgina LRU, trae pginas almacenas en el
Buffer Pool del disco a travs del Mdulo de E/S; y el Procesador de Consultas soporta en
este caso las consultas de los pares ms cercanos (CPC y K-CPC). Tambin, debemos
destacar la presencia en memoria de un path-buffer por cada R*-tree, donde estn
almacenados los nodos del camino actual en el recorrido del R*-tree asociado.
Resultados experimentales y aplicacin
215

R
P

Mdulo de E/S
Buffer Local
LRU (R
P
)
CPC/K-CPC
R
Q

Buffer Local
LRU (R
Q
)

Figura 6.16 Esquema de buffer Local para la consulta de los pares ms cercanos.
La estructura general del buffer LRU de pginas almacenado en memoria (buffer pool),
local a cada uno de los R*-trees es la que se muestra en la Figura 6.17. En ella podemos
apreciar que hay B pginas de datos que se corresponden con un nodo (interno u hoja) del R*-
tree. Para gestionar esta estructura de datos con una poltica de reemplazo LRU necesitamos
un contador global, denominado lruCount, que se incrementa cada vez que la consulta
requiere una pgina (referenciada por primer vez o re-referenciada). Para identificar a cada
pgina necesitamos saber su nmero de registro absoluto en el archivo del ndice (direccion),
y el valor de lruCount que indica cuando dicha pgina fue referenciada por ltima vez
(lruVal). Evidentemente, si queremos evitar recorrer todas las pginas del buffer cuando una
pgina cualquiera es requerida, podemos incluir una tabla hash adicional organizada segn el
nmero de registro absoluto de las pginas en el archivo de ndice, reduciendo el tiempo de
respuesta de la consulta cuando hay un buffer LRU de gran tamao.

0 1 2 3

B 1
Pginas de Datos = Nodos del R*-tree

lruVal
direccion
estado
lruVal
direccion
estado
lruVal
direccion
estado
lruVal
direccion
estado
lruVal
direccion
estado

Figura 6.17 Estructura de datos de un buffer de pginas almacenado en memoria (buffer
pool).
Captulo 6
216
El algoritmo de reemplazo de pgina LRU para la operacin de lectura es el que vamos a
utilizar en nuestros experimentos. ste se basa en que las pginas que se han utilizado mucho
en las ltimas operaciones, probablemente se utilizarn mucho en las siguientes. Por otro
lado, las pginas que hace mucho tiempo que no se utilizan, probablemente seguirn sin
utilizarse durante largo tiempo. Esta idea sugiere un algoritmo sencillo: cuando ocurra una
falta de pgina, se reemplazar la pgina del buffer que haya estado ms tiempo sin
utilizarse. Esta estrategia se denomina LRU (menos utilizada recientemente) y el algoritmo de
reemplazo de pgina para la operacin de lectura es el que se muestra a continuacin:
ReemplazamientoLRU(direccionPagina: DireccionPagina, buffer: BufferPaginas)
01 for every pagina p
i
del buffer do
02 if buffer[p
i
].direccion = direccionPagina then
03 lruCount++;
04 buffer[p
i
].lruVal = lruCount;
05 return buffer[p
i
].pagina;
06 endif
07 enddo
08 Min = ;
09 for every pagina p
i
del buffer do
10 if buffer[p
i
].estado = libre then
11 victima = p
i
;
12 break;
13 else
14 if (buffer[p
i
].lruVal < Min) then
15 victima = p
i
;
16 Min = buffer[p
i
].lruVal;
17 endif
18 endif
19 enddo
20 buffer[victima].pagina = LeerPagina(direccionPagina);
21 buffer[victima].direccion = direccionPagina;
22 lruCount++;
23 buffer[victima].lruVal = lruCount;
24 buffer[victima].estado = ocupada;
25 return buffer[victima].pagina;
Adems de considerar un buffer LRU vinculado a cada R*-tree, le hemos asociado a cada
de ellos un path-buffer, donde estn almacenados los nodos del camino actual en el recorrido
de cada R*-tree desde la raz hasta las hojas. Dicha estructura de buffer est formada por un
nodo asociado a cada uno de los niveles del rbol y enlazados de la misma forma que lo estn
en l. Es decir, el nodo raz estar como primer elemento del path-buffer apuntando a uno de
sus hijos, ste a su vez apuntar a otro hijo suyo, y as sucesivamente hasta llegar el nivel de
las hojas, tal y como se muestra en la Figura 6.18. La gestin del path-buffer es independiente
del buffer LRU, aunque ambos estn asociados a cada un de los R*-trees. De forma general,
el funcionamiento es el siguiente: cuando el algoritmo que procesa la consulta requiere una
pgina de un determinado R*-tree, primero busca dicha pgina en el path-buffer asociado, y si
la pgina deseada no se encuentra en ste, entonces busca en su buffer LRU, producindose
una falta de pgina y el correspondiente acceso a disco si sta no est presente.
Resultados experimentales y aplicacin
217

R*-tree

Altura 1
Path-Buffer
0
Altura 2
Altura 3
Nodo
0

Nodo
i

i
Nodo
Altura-3

Nodo
Altura-2

Raz = Nodo
Altura-1


Figura 6.18 Estructura de un path-buffer asociado a un R*-tree.

Evaluacin de los resultados
Para realizar los experimentos que muestren el comportamiento de los algoritmos (nmero de
accesos a disco) ante la presencia de un buffer de pginas gestionado mediante una poltica de
reemplazo LRU hemos utilizado los mismos conjuntos de datos que en experimentos
anteriores, es decir, puntos reales y reales movidos aleatoriamente con idntica cardinalidad
(62556 puntos), dando lugar a R*-trees con la misma altura (4). Tambin debemos indicar que
los resultados de los experimentos sobre puntos sintticos (uniformes y generados
aleatoriamente) han seguido tendencias similares.
En primer lugar, merece especial atencin considerar el efecto de incluir un path-buffer
sobre los algoritmos recursivos e iterativos. Para CPC, la inclusin un path-buffer supone un
ahorro del 30% en el nmero de accesos a disco para el algoritmo recursivo en su variante
STD, mientras que para el algoritmo iterativo utilizando la misma variante (HEAP_STD) es
del 26%. El motivo de esta diferencia es debido a que el uso de la recursividad sobre el path-
buffer beneficia ms al algoritmo que sigue un recorrido en profundidad (recursivo), que al
algoritmo que sigue una estrategia de bsqueda de primero el mejor utilizando un montculo
mnimo global (iterativo). En lo que respecta a K-CPC, hemos escogido la variante STD para
comparar el algoritmo recursivo con el iterativo, obteniendo la Tabla 6.26, que muestra el
porcentaje de ahorro que supone incluir un path-buffer para cada valor de K. En promedio,
incluir un path-buffer supone un ahorro del 27% para el algoritmo recursivo y del 22% para el
iterativo, lo que indica una mejora del 3% al 5% del recursivo respecto del iterativo.

1 10 100 1000 10000 100000 1000000
RECU_STD 29.94% 29.86% 29.67% 29.03% 27.20% 22.62% 16.41%
HEAP_STD 25.08% 25.02% 24.70% 22.66% 22.12% 20.02% 13.04%
Tabla 6.26 Porcentaje de ahorro que supone incluir un path-buffer en los algoritmos para K-
CPC.
Captulo 6
218
Una vez visto el efecto de incluir un path-buffer, vamos a estudiar el ahorro de operaciones
de E/S que supone aadir un buffer LRU, suponiendo siempre la existencia de dicho path-
buffer. Para este caso, hemos estudiado todas las variantes del algoritmo recursivo y del
iterativo, y de los resultados obtenidos debemos indicar que para CPC, la mejor de todas fue
STD. En la Tabla 6.27, mostramos los accesos a disco para cada una de ellas y la ganancia
que supone incluir un buffer LRU que tiene el algoritmo recursivo respecto del iterativo.

0 4 8 16 32 64 128 256 512 1024
RECU_STD 26508 24354 21178 17845 15637 14569 13341 11998 10518 10262
HEAP_STD 27924 25815 22875 19763 17555 16044 14761 13569 12690 11697
Ahorro (%) 5.07% 5.66% 7.42% 9.71% 10.93% 9.19% 9.62% 11.58% 17.12% 12.27%
Tabla 6.27 Nmero de accesos a disco y porcentaje de ahorro del algoritmo recursivo
(RECU_STD) respecto del iterativo (HEAP_STD) para CPC, utilizando un buffer de pginas
de tamao variable (0 B 1024) y gestionado con una poltica LRU.
En la Figura 6.19 podemos apreciar el efecto de incluir un buffer LRU con un tamao
variable de pginas (B, desde 0 hasta 1024) para la consulta del par ms cercano (CPC)
utilizando el algoritmo recursivo (RECU_STD) y el iterativo (HEAP_STD). En dicha grfica
podemos observar la diferencia que existe entre los dos algoritmos, siendo el recursivo, en
promedio, un 10% mejor que el iterativo. La razn fundamental de esta diferencia radica en
que un buffer de pginas con una poltica de reemplazo LRU (sustituye del buffer la pgina
menos utilizada recientemente, dando ms prioridad a las que tienen una referencia ms
reciente) mejora el rendimiento (nmero de operaciones de E/S) de un algoritmo que hace uso
de la recursividad respecto a otro que la evita utilizando un montculo mnimo global
combinado con una poltica de bsqueda de primero el mejor.
10000
14000
18000
22000
26000
30000
0 4 8 16 32 64 128 256 512 1024
Tamao del Buffer (en Pginas)
A
c
c
e
s
o
s

a

D
i
s
c
o
RECU_STD HEAP_STD

Figura 6.19 Efecto de incluir un buffer de pginas de tamao variable al aplicar el
algoritmo recursivo (RECU_STD) y el iterativo (HEAP_STD) para obtener el par ms
cercano (CPC).
Una vez visto el comportamiento de los algoritmos para CPC ante la inclusin de un buffer
de pginas gestionado con una poltica de reemplazo LRU, vamos a analizar el efecto que ste
Resultados experimentales y aplicacin
219
supone para K-CPC. En primer lugar, podemos apreciar en la Figura 6.20 (Tabla 6.28) que el
algoritmo recursivo (RECU_STD), cuando B 32, el ahorro en trmino de accesos a disco es
muy elevado y prcticamente el mismo para todos los valores de K. Tambin es interesante
resaltar el pico que se produce cuando B 16 y K 100000 (en particular, cuando B = 0 y K
= 1000000).

0 4 8 16 32 64 128 256 512 1024
1 26508 24354 21178 17845 15637 14569 13341 11998 10518 10262
10 26664 24489 21286 17905 15670 14601 13364 12010 10526 10268
100 27074 24839 21551 18041 15723 14654 13406 12034 10537 10279
1000 28401 25958 22387 18517 15913 14807 13528 12096 10556 10295
10000 32951 29919 25282 20090 16579 15274 13882 12278 10648 10362
100000 49287 44338 36318 26290 18842 16859 14986 12830 10847 10560
1000000 113378 101372 81034 52005 27096 22152 19076 14980 11638 11147
Tabla 6.28 Nmero de accesos a disco del algoritmo recursivo (RECU_STD) para K-CPC
utilizando un buffer de pginas LRU de tamao variable (0 B 1024).
0
4
8
16
32
64
128
256
512
1024
1
100
10000
1000000
0
24000
48000
72000
96000
120000
A
c
c
e
s
o
s

a

D
i
s
c
o
Tamao del Buffer
# Pares
0-24000 24000-48000 48000-72000 72000-96000 96000-120000

Figura 6.20 Nmero de accesos a disco del algoritmo recursivo (RECU_STD) para K-
CPC utilizando un buffer de pginas LRU de tamao variable.
Para el caso del algoritmo iterativo (HEAP_PS, variante iterativa con mejor
comportamiento ante la presencia de un buffer LRU de gran tamao), podemos apreciar en la
Figura 6.21 (Tabla 6.29) como sigue una tendencia parecida a la variante del algoritmo
recursivo, aunque para valores de K muy altos (K 10000), el ahorro de operaciones de E/S
es considerablemente menor que el que se produce cuando aplicamos el algoritmo recursivo.


Captulo 6
220
0 4 8 16 32 64 128 256 512 1024
1 28895 25661 22088 19661 18027 16456 15040 13902 12941 11996
10 29148 25895 22436 19982 18195 16665 15178 13913 12749 11858
100 29289 26014 22502 19980 18179 16522 14978 13826 12647 11782
1000 30246 27049 23519 20892 19074 17538 16041 14753 13596 12727
10000 32341 29013 25489 22941 21207 19780 18346 17099 16030 15220
100000 40609 37428 33668 31060 29407 27965 26576 25327 24075 22577
1000000 72650 69402 65662 63026 61307 59802 58179 56572 54143 50020
Tabla 6.29 Nmero de accesos a disco del algoritmo iterativo (HEAP_PS) para K-CPC
utilizando un buffer de pginas LRU de tamao variable (0 B 1024).
0
4
8
16
32
64
128
256
512
1024
1
100
10000
1000000
0
15000
30000
45000
60000
75000
A
c
c
e
s
o
s

a

D
i
s
c
o
Tamao del Buffer
# Pares
0-15000 15000-30000 30000-45000 45000-60000 60000-75000

Figura 6.21 Nmero de accesos a disco del algoritmo iterativo (HEAP_PS) para K-CPC
utilizando un buffer de pginas LRU de tamao variable.
De los datos de las Tablas 6.28 y 6.29 podemos extraer grficas que representen el
porcentaje de ganancia para K-CPC que supone incrementar el tamao del buffer de pginas
(B > 0) con respecto a la ausencia del mismo (B = 0). Para el algoritmo recursivo
(RECU_STD), como se observa en la Figura 6.22, el porcentaje de ahorro crece con el
incremento del tamao del buffer para todos los valores de K, especialmente para los casos en
que K 100000. Por otro lado, el comportamiento del algoritmo iterativo (HEAP_PS) es
completamente diferente (Figura 6.23). Cuando el tamao del buffer crece, el porcentaje de
ahorro para el nmero de accesos a disco tambin se incrementa, aunque en menor medida
que la variante recursiva, pero fijar un tamao del buffer provoca un descenso en el porcentaje
de ahorro cuando el valor de K se incrementa. Por ejemplo, cabe destacar que el algoritmo
recursivo proporciona un ahorro en el rango del 60% al 90% (tendencia ascendente) cuando
se incrementa el valor de K (1..1000000) y el tamao del buffer es de 512 pginas respecto al
caso en el que no hay buffer (B = 0), mientras que para el algoritmo iterativo bajo las mismas
condiciones del buffer, dicho ahorro est en el rango del 55% al 25% (tendencia descendente).
Resultados experimentales y aplicacin
221
4
8
16
32
64
128
256
512
1024
1
100
10000
1000000
0%
20%
40%
60%
80%
100%
P
o
r
c
e
n
t
a
j
e

d
e

A
h
o
r
r
o
Tamao del Buffer
# Pares
0%-20% 20%-40% 40%-60% 60%-80% 80%-100%

Figura 6.22 Porcentaje de ahorro para K-CPC con el algoritmo recursivo (RECU_STD),
variando el tamao del buffer (B > 0) con respecto a B = 0.
4
8
16
32
64
128
256
512
1024
1
100
10000
1000000
0%
12%
24%
36%
48%
60%
P
o
r
c
e
n
t
a
j
e

d
e

A
h
o
r
r
o
Tamao del Buffer
# Pares
0%-12% 12%-24% 24%-36% 36%-48% 48%-60%

Figura 6.23 Porcentaje de ahorro para K-CPC con el algoritmo iterativo (HEAP_PS),
variando el tamao del buffer (B > 0) con respecto a B = 0.
Para finalizar esta seccin, vamos a comparar la utilizacin del algoritmo recursivo
(RECU_STD) y del iterativo (HEAP_STD), sobre la consulta de los K pares ms cercanos
(K-CPC) cuando tenemos presente un buffer LRU de tamao fijo (B = 512). En la Tabla 6.30
podemos ver el nmero de accesos a disco (representado grficamente en la Figura 6.24) y el
ahorro que supone ejecutar el algoritmo recursivo frente al iterativo. La diferencia es del 20%
al 30% ciando K 10000, pero cuando K 100000 es muy superior, llegando a ser del 55%
Captulo 6
222
cuando K = 100000 y del 79% cuando K = 1000000. Adems, el incremento del valor de K
no supone un gasto sustancial en el nmero de accesos a disco para el algoritmo recursivo
cuando B = 512, slo un gasto extra del 3% (de K = 1 a K = 100000) y del 10% (de K = 1 a K
= 1000000). Por otra parte, este incremento de K para el algoritmo iterativo s supone un
considerable aumento en el nmero de operaciones de E/S con el mismo tamao del buffer (B
= 512), un gasto extra del 46% (de K = 1 a K = 100000) y del 76% (de K = 1 a K = 1000000).

1 10 100 1000 10000 100000 1000000
RECU_STD 10518 10526 10537 10556 10648 10847 11638
HEAP_PS 12941 12749 12647 13596 16030 24075 54143
Ahorro (%) 18.72% 17.44% 16.68% 22.36% 33.57% 54.94% 78.51%
Tabla 6.30 Nmero de accesos a disco del algoritmo recursivo (RECU_STD) e iterativo
(HEAP_PS) para K-CPC utilizando un buffer LRU de tamao fijo (B = 512) y siendo variable
el valor de K. Comparativa del porcentaje de ahorro del recursivo frente al iterativo.
10000
13000
16000
19000
22000
25000
1 10 100 1000 10000 100000
Tamao del Buffer (en Pginas)
A
c
c
e
s
o
s

a

D
i
s
c
o
RECU_STD HEAP_PS

Figura 6.24 Nmero de accesos a disco para K-CPC utilizando los algoritmos, recursivo
(RECU_STD) e iterativo (HEAP_PS), fijando el tamao del buffer (B = 512) y tomando
como parmetro variable el valor de K.
A ttulo de comentario podemos decir, que para estos experimentos hemos utilizado un
esquema de buffer Local, en el que cada R*-tree tiene su fraccin de buffer independiente y
de igual tamao. Aunque, tambin se podra haber empleado un esquema de buffer Global
(Figura 6.25), donde los dos R*-trees comparten el buffer de pginas a nivel global y el path-
buffer desaparece. En [CVM01] se sugiere este ltimo esquema, ya que adems de
proporcionar resultados muy similares al esquema de buffer Local (en algunos casos,
mejores), el Gestor del Buffer podra:
Incluir y gestionar ms de dos R*-trees en el mismo buffer de pginas.
Dar mayor prioridad a algunos de los R*-trees que intervienen en la consulta.
Resultados experimentales y aplicacin
223
Gestionar y asignar dinmicamente ms pginas a un determinado R*-tree, reduciendo
el nmero de pginas que se la asignarn al otro.
Introducir tcnicas de optimizacin global para reducir an ms el nmero de accesos
a disco.

R
P

Mdulo de E/S
CPC/K-CPC
R
Q

Buffer Global LRU

Figura 6.25 Esquema de buffer Global para la consulta de los pares ms cercanos.

Conclusiones
De los anteriores resultados podemos extraer las siguientes conclusiones respecto a la
inclusin de buffers en la consulta de los pares ms cercanos:
1. Incluir un path-buffer supone un mayor ahorro para el algoritmo recursivo que para el
iterativo. La razn es que el uso de la recursividad combinado con un recorrido en
profundidad consigue que el nodo que se accede en la fase de backtracking se encuentre
siempre en el path-buffer, ya que ste se obtuvo en la fase de expansin. En cambio,
esto no ocurre en el algoritmo iterativo.
2. Evidentemente, cuanto mayor es el tamao del buffer LRU (B), mayor es el ahorro de
operaciones de E/S, utilizando cualquier algoritmo (recursivo o iterativo) para dar
solucin a K-CPC. Esto se debe a que mantener una parte del ndice en memoria
principal combinado con una poltica de reemplazo de pgina como es LRU (da
prioridad a las pginas ms recientemente referenciadas), reduce notablemente el
nmero de accesos a disco.
3. De los resultados obtenidos podemos destacar que la influencia del esquema de
buffering Local con una poltica de reemplazo LRU asociado a cada uno de los R*-trees
afecta de forma ms significativa a las variantes del algoritmo recursivo que a las del
iterativo. La razn fundamental nuevamente, es que el uso de la recursividad en un
algoritmo que sigue un recorrido en profundidad afecta al rendimiento de la consulta en
presencia de un buffer local a cada R*-tree, mucho ms que al algoritmo que sigue una
Captulo 6
224
estrategia de bsqueda basada en primero el mejor utilizando un montculo mnimo
global para evitar la recursividad.
4. Con un tamao de buffer fijo, el incremento del nmero de pares (K) en la consulta K-
CPC para el algoritmo recursivo supone un gasto casi despreciable comparado con el
que supone ejecutar la misma consulta con el algoritmo iterativo. Esto se debe al
recorrido que siguen los algoritmos, vindose ms favorecido el que sigue un recorrido
en profundidad utilizando la recursividad, ya que empleando una poltica de reemplazo
de pgina LRU, en la fase de backtracking las pginas referenciadas recientemente van
a estar en el buffer con una gran probabilidad. En cambio, el algoritmo iterativo que
utiliza un montculo mnimo global no sabe a priori, si la pgina a utilizar puede estar o
no en el buffer.

6.6 Comparacin con la alternativa incremental

Alternativa incremental. Caractersticas y algoritmos
Como hemos comentado en el captulo 2, existen dos trabajos [HjS98, SML00] que tratan K-
CPC sobre R-trees pero desde una perspectiva incremental. En [HjS98] se presenta un
algoritmo incremental e iterativo para resolver el Join Basado en Distancias (una aplicacin
directa de esta operacin es encontrar los K pares ms cercanos), en el sentido de que los
pares se devuelven uno a uno en orden ascendente de distancia (en ranking) y el usuario
dispone de parte del resultado antes de la finalizacin del algoritmo. En [SML00] se presentan
mejoras al trabajo propuesto en [HjS98] de su variante Simultaneous, que denominan Join
Basado en Distancias Adaptativo Multi-Etapa. En ste se aplican mtodos multi-etapa, la
tcnica de Barrido del Plano y conceptos relacionados con el eje y direccin de barrido como
criterios de optimizacin. Adems, esta ltima mejora, al ser un esquema multi-etapa, utiliza
colas de prioridad adicionales que mejoran el rendimiento de la consulta sobre todo cuando el
valor de K es grande.
En [HjS98] se define el Join Basado en Distancias, que calcula el subconjunto del
producto cartesiano de dos conjuntos de objetos indexados en dos R-trees especificando un
orden sobre los elementos del conjunto final basado en la distancia Eucldea. En [HjS98] se
presentan tres variantes del algoritmo, que se clasifican en funcin de la poltica con la que se
recorran los R-trees. Si la prioridad se le da arbitrariamente a uno de los dos R-trees (por
ejemplo, a R
P
) tenemos la variante Basic. Si la prioridad la tiene el componente del par con
menor profundidad obtenemos la variante Evenly (si ambos elementos en el par tienen el
mismo nivel en sus respectivos R-trees, entonces se escoge para procesar el componente del
par cuyo MBR tiene mayor rea). Y si todos los posibles pares de elementos generados son
candidatos para el recorrido de los rboles, surge la alternativa Simultaneous.
El algoritmo incremental que lleva a cabo el Join Basado en Distancias tiene como ncleo
para su funcionamiento una cola de prioridad (implementada como un montculo mnimo),
donde cada elemento es un par formado por un componente de R
P
y otro de R
Q
, es decir,
tendremos pares de la forma: MBR/MBR, MBR/OBJ, OBJ/MBR y OBJ/OBJ. La clave
Resultados experimentales y aplicacin
225
utilizada para ordenar los elementos en la cola de prioridad es la mnima distancia que hay
entre los miembros del par.
Debido a que el usuario puede desear obtener K pares de objetos, dicho algoritmo debe
estimar la distancia mxima de los pares que han sido encontrados hasta el momento.
Evidentemente, si se han seleccionado K pares de la forma OBJ/OBJ, entonces el par con la
mayor distancia entre esos K pares establecer una cota inferior sobre la distancia mxima
necesaria para calcular los K pares ms cercanos. No obstante, tambin se puede hacer uso de
otros tipos de pares, como por ejemplo MBR/MBR, para llevar a cabo el mismo proceso. Si
denotamos a D
max
como la distancia mxima impuesta sobre los pares (se ir actualizando
durante el procesamiento del algoritmo), y a MaxMaxDist como la funcin de distancia que
calcula una cota superior sobre la distancia de cualquier par de objetos cubiertos por un par de
MBRs. El objetivo es ir reduciendo D
max
(fijada inicialmente a ) lo mximo posible
dependiendo de K (nmero mximo de pares requeridos). Un par (MBR
P
, MBR
Q
) se elige
para estimar D
max
si verifica que MaxMaxDist(MBR
P
, MBR
Q
) D
max
, garantizando que todos
los pares OBJ/OBJ generados de (MBR
P
, MBR
Q
) tendrn una distancia en el rango [0, D
max
].
El proceso para ir actualizando D
max
(valor de distancia para que los pares que se vayan
generando se inserten en la cola de prioridad cuando queremos determinar los K pares ms
cercanos) va a depender de K. Para poder llevar a cabo dicho proceso de actualizacin es
necesario mantener un conjunto adicional de pares (MBR
P
, MBR
Q
), denominado M, que
incluya cada uno de los pares que se han insertado en la cola de prioridad, pero no han sido
procesados todava. El procedimiento que actualiza M y D
max
tiene en cuenta los siguientes
puntos:
Cuando un par (MBR
P
, MBR
Q
) verifica que MinMinDist(MBR
P
, MBR
Q
) D
max
, ste
se inserta en la cola de prioridad y tambin en M. Si la insercin del par provoca que la
suma de pares OBJ/OBJ que se pueden generar de los pares que hay en ese momento en
M es mayor que K, entonces borramos pares de M (con el mayor valor de MaxMaxDist)
hasta que la suma sea menor o igual que K, estableciendo D
max
al valor de MaxMaxDist
del ltimo par borrado.
Cuando un par (MBR
P
, MBR
Q
) se extrae de la cola de prioridad debe borrarse tambin
de M, si est presente.
Cuando devolvemos el siguiente par OBJ/OBJ ms cercano, entonces se reduce el
valor de K en uno.
Una pregunta clave que se plantea en [HjS98] es la siguiente: cmo organizar de forma
ptima este conjunto de pares adicional denominado M?. Para ello es necesario saber las
operaciones que se van a realizar sobre dicha estructura de datos, y stas son: insertar un par
de MBRs, eliminar el par de MBRs con el mayor valor de MaxMaxDist y eliminar un par de
MBRs determinado. No existe una estructura que soporte estas tres operaciones
simultneamente, y para conseguirlo, en [HjS98] utilizan una cola de prioridad Q
M
,
implementada como un montculo mximo (en la raz se coloca el par de MBRs con el mayor
valor de MaxMaxDist) y una tabla hash ahocicada a dicha cola de prioridad para localizar un
par determinado organizada segn MaxMaxDist. Cada elemento de esta tabla hash contiene
un puntero a la correspondiente entrada en la cola de prioridad Q
M
, pudiendo eliminar de Q
M

cualquier par de MBRs.
Captulo 6
226
Como hemos indicado anteriormente, en la implementacin de este algoritmo incremental,
todos los posibles tipos de pares se insertan en la cola de prioridad principal, y el tamao de
sta puede ser extraordinariamente grande dependiendo del tamao de los rboles (R
P
y R
Q
).
Por ello, en [HjS98], la cola de prioridad se almacena parcialmente en memoria principal (una
parte es una cola de prioridad implementada como un montculo mnimo y la otra es una lista
desordenada) y el resto en disco (como un conjunto de listas enlazadas basadas en distancias).
La distincin del tamao de cada parte (memoria o disco) es muy importante para el
rendimiento del algoritmo, ya que se almacenan en disco pares que probablemente nunca se
accedern. El tamao de cada parte est fuertemente condicionado por la eleccin de una
constante denominada D
T
, que fragmenta la recta real en un nmero determinado de
intervalos de distancia. En [SML00] se propone un esquema similar, no utilizando la lista
desordenada en memoria y los elementos en disco se almacenan de forma desordenada.

Comparativa de resultados
Para realizar los experimentos que muestren el comportamiento de los algoritmos
incrementales frente a los no incrementales hemos utilizado los mismos conjuntos de datos
que en experimentos anteriores, es decir, puntos reales y reales movidos aleatoriamente con
idntica cardinalidad (62556 puntos), dando lugar a R*-trees con la misma altura (4). En el
apndice A presentamos los seudo-cdigos de los algoritmos incrementales [HjS98]
implementados para esta comparacin.
Tambin, debemos indicar que los resultados obtenidos de aplicar los algoritmos
incrementales para K-CPC son relativos a la finalizacin de los mismos (devolver los K pares
ms cercanos al final), aunque siguiendo su funcionamiento normal, el usuario puede disponer
de parte del resultado durante la ejecucin de los mismos. Con esto queremos decir que estos
algoritmos funcionan de manera incremental pero devuelven el resultado de forma no
incremental, teniendo as sentido la comparativa con nuestros algoritmos.
En primer lugar vamos a comparar el nmero de accesos a disco que tienen las tres
variantes del algoritmo incremental Basic (BAS), Evenly (EVN) y Simultaneous (SML), con
nuestros algoritmos recursivo (RECU_STD) e iterativo (HEAP_STD) en la variante STD para
K-CPC, segn se indica en la Tabla 6.31. Para los algoritmos incrementales establecemos
arbitrariamente D
T
= 500.

BAS EVN SML RECU_STD HEAP_STD
1 276744 72512 37830 37838 37830
10 277153 72796 37906 38018 37906
100 278701 73909 38194 38494 38194
1000 283185 76958 38970 40018 38970
10000 297930 87629 41782 45260 41782
100000 347884 125442 50546 63694 50546
Tabla 6.31 Nmero de accesos a disco de los algoritmos incrementales y los no
incrementales (recursivo e iterativo) en su variante STD para K-CPC, no teniendo presenta
un buffer LRU (B = 0).
Resultados experimentales y aplicacin
227
De dicha tabla podemos concluir que en ausencia de buffer (B = 0) las variantes SML y
HEAP_STD son las que tienen el menor nmero de accesos a disco, y ste es el mismo para
todos los valores de K. El motivo de esta igualdad es porque en Simultaneous, al igual que
HEAP_STD, todos los posibles pares de elementos generados de dos nodos internos son
candidatos para el recorrido de los rboles, aunque en HEAP_STD no se insertan pares de la
forma MBR/OBJ, OBJ/MBR y OBJ/OBJ. Tambin podemos destacar el elevado nmero de
operaciones de E/S que tiene la variante BAS respecto a SML y HEAP_STD, siendo sta, en
promedio, el 85% ms costosa. La variante RECU_STD tiene valores muy prximos a
HEAP_STD para valores de K pequeos (K 1000), aunque la diferencia llega a ser del 20%
para K = 100000.
Intentando reducir el nmero de accesos a disco, vamos a incluir un buffer LRU de 512
pginas, 256 para cada R*-tree, obteniendo los resultados que se muestran en la Tabla 6.32.
En este caso, la variante STD de la versin recursiva (RECU_STD) es la ganadora para todos
los valores de K. Interesantes resultan los valores obtenidos por BAS y EVN para K igual a 1
y 10, siendo incluso mejores que SML, aunque para valores de K 100, esta ltima variante
incremental obtiene los mejores resultados. Por ejemplo, para K = 100000 el ahorro en el
nmero de accesos a disco de RECU_STD respecto a SML y HEAP_STD es del 57% y 55%,
respectivamente.

BAS EVN SML RECU_STD HEAP_STD
1 11764 11875 12262 10518 13221
10 12459 12238 12572 10526 13715
100 14029 14587 13404 10537 13812
1000 18320 17754 14565 10556 13436
10000 31730 27774 17360 10648 16006
100000 75146 62017 25379 10847 24165
Tabla 6.32 Nmero de accesos a disco de los algoritmos incrementales y los no
incrementales (recursivo e iterativo) en su variante STD, para K-CPC teniendo presente un
buffer LRU de 512 pginas (B = 512).
En la Figura 6.26 se puede observar la tendencia de los algoritmos segn el nmero de
accesos a disco para K-CPC, destacando que en presencia de un buffer LRU, el gasto extra
que supone obtener el par ms cercano o los 100000 pares ms cercano es del 3% para
RECU_STD, y del 52% para SML (variante con mejor comportamiento del algoritmo
incremental). Comparando los algoritmos iterativos, incremental (SML) y no incremental
(HEAP_STD), podemos observar que para K 100, SML obtiene mejores resultados (ahorro
del 7% al 3%), pero cuando K 1000, HEAP_STD resulta tener un nmero menor de accesos
a disco (ahorro del 8% al 5%). Adems, entre RECU_STD y SML existe una diferencia del
57% como gasto adicional para obtener los 100000 pares ms cercanos, siendo slo del 14%
cuando K = 1. Con estos resultados podemos confirmar la gran influencia que tiene un buffer
de pginas almacenado en memoria principal sobre el algoritmo recursivo, producindose un
ahorro del 83% para K = 100000, de no tener buffer (B = 0) a tener 512 pginas (B = 512) de
buffer gestionadas con una poltica de reemplazo LRU con un esquema Local.
Captulo 6
228
10000
24000
38000
52000
66000
80000
1 10 100 1000 10000 100000
Nmero de Pares
A
c
c
e
s
o
s

a

D
i
s
c
o
BAS EVN SML RECU_STD HEAP_STD

Figura 6.26 Nmero de accesos a disco de los algoritmos incrementales y los no
incrementales (recursivo e iterativo) en su variante STD, para K-CPC teniendo presente un
buffer LRU de 512 pginas.
Otros parmetros que merecen ser estudiados son la memoria principal requerida por los
algoritmos iterativos y el nmero de inserciones en la cola de prioridad principal de los
algoritmos incrementales y en el montculo mnimo global para los no incrementales
(independientemente del tamao del buffer LRU). Para comparar la memoria ocupada por las
estructuras de datos (montculos) que se utilizan para evitar la recursividad no se considera el
rea de disco adicional ocupada por los algoritmos incrementales, lo cual requiere un gasto
adicional de tiempo para llevar a cabo las inserciones y eliminaciones de pares en memoria
secundaria. Es decir, para los algoritmos incrementales consideramos el nmero mximo de
elementos en la cola de prioridad en memoria principal segn el valor de D
T
. Debemos
recordar, como caracterstica importante, que en la cola de prioridad se insertan pares de la
forma: MBR/MBR, MBR/OBJ, OBJ/MBR y OBJ/OBJ, mientras que en el montculo mnimo
slo hay pares de la forma: MBR/MBR. En la Tabla 6.33 mostramos el nmero mximo de
pares en la cola de prioridad (incrementales) y montculo mnimo (no incrementales), ambos
inicializados con el mismo tamao, destacando que debe existir una cola de prioridad (Q
M
)
adicional (implementada como un montculo mximo y organizado segn MaxMaxDist) de
tamao variable segn el valor de K para los algoritmos incrementales y de tamao K
(KMasCercanos, que es donde se almacena el resultado final) para los no incrementales. En
dicha tabla podemos observar que el nmero de pares en memoria principal para SML (mejor
variante incremental) es menor que para HEAP_STD hasta que K = 10000 (28%), pero
cuando K = 100000, resulta ser al contrario, y utilizar HEAP_STD supone un ahorro del 24%
con respecto a SML. La razn de este comportamiento en SML se debe fundamentalmente a
que cuando K crece, el nmero de pares en la cola de prioridad en memoria tambin aumenta,
aunque en disco se hayan almacenado muchos de ellos que no ha sido necesario utilizarlos.
Adems, cuando K 10000, los pares que se almacenan en disco se emplean durante el
procesamiento del algoritmo con el objetivo de obtener los pares ms cercanos deseados.



Resultados experimentales y aplicacin
229
BAS EVN SML HEAP_STD
1 1300 872 603 7403
10 2233 1871 776 8029
100 7207 4132 2022 8448
1000 15716 12553 6068 9579
10000 33048 26261 14734 20343
100000 85457 78823 66325 50361
Tabla 6.33 Nmero mximo de pares en memoria principal de los algoritmos iterativos
incrementales y los no incrementales en su variante STD (HEAP_STD), para K-CPC.
En lo que concierne al nmero de inserciones en la cola de prioridad y en el montculo
principal podemos observar, en la Tabla 6.34, el comportamiento de las variantes
incrementales con respeto a la variante STD no incremental e iterativa. Destacamos que SML
es el que obtiene los mejores resultados cuando K 100 (K = 1, 19% menor que
HEAP_STD), pero cuando K 1000, HEAP_STD es el que presenta un menor nmero de
inserciones en la estructura de datos principal para procesar el algoritmo de forma iterativa (K
= 100000, 86% menor que SML).
Por tanto, en lo que respecta a estos dos ltimos parmetros en estudio, podemos decir que
el algoritmo incremental es competitivo comparado con el no incremental e iterativo
(HEAP_STD) cuando el valor de K es reducido (K 100), teniendo un peor comportamiento
cuando K es grande (K 1000).

BAS EVN SML HEAP_STD
1 339739 72945 19381 23912
10 340841 73808 19664 24137
100 344542 77306 21274 24914
1000 361431 92108 31006 27039
10000 449154 166067 94797 38185
100000 916887 528288 486934 68454
Tabla 6.34 Nmero de pares insertados en la cola de prioridad de los algoritmos
incrementales y en el montculo mnimo principal de los no incrementales e iterativos en su
variante STD, para K-CPC.
A continuacin vamos a comparar el tiempo total de respuesta (segundos) requerido para
poder llevar a cabo la consulta. Para ello, vamos a utilizar los mismos parmetros
experimentales que hemos fijado para realizar las comprobaciones anteriores y un buffer LRU
de 512 pginas, de las que 256 se vinculan de forma local a cada uno de los R*-trees. Como
hemos podido comprobar anteriormente la variante PS es la que obtiene los menores tiempos
de respuesta para los algoritmos no incrementales (recursivos o iterativos), por ello, sta es la
elegida para compararla con las diferentes versiones del algoritmo incremental. En la Tabla
6.35 podemos observar el tiempo de respuesta (segundos) empleado por las diferentes
alternativas de los algoritmos para K-CPC.


Captulo 6
230
BAS EVN SML RECU_PS HEAP_PS
1 18.76 7.57 15.19 1.48 2.40
10 23.16 8.81 15.22 1.50 2.44
100 32.06 10.81 16.00 1.56 2.56
1000 43.30 15.07 18.21 1.78 3.17
10000 86.10 40.69 39.60 3.08 4.79
100000 8284.13 7200.46 5412.38 14.67 13.58
Tabla 6.35 Tiempo de respuesta en segundos para K-CPC sobre los algoritmos
incrementales y no incrementales (recursivo e iterativo en su variante PS), sobre R*-trees
procedentes de la indexacin de puntos reales y reales movidos aleatoriamente, y utilizando
un buffer LRU de 512 pginas.
El aspecto ms relevante de la tabla anterior es la gran cantidad de tiempo requerido por
los algoritmos incrementales para K = 100000, recordando que este tiempo es el que tarda el
algoritmo en devolver los K pares (todos) aunque el usuario puede disponer de parte del
resultado antes de la finalizacin del mismo. La razn de este valor tan grande es
fundamentalmente por el elevado nmero de inserciones y extracciones que se deben hacer
sobre la cola de prioridad principal y en la auxiliar (Q
M
), adems del tiempo requerido para
almacenar la fraccin de pares en disco (parte de la cola de prioridad). Tambin podemos
observar que RECU_PS es la variante ms rpida para valores de K 10000, mientras que
para K = 100000 la variante ganadora es HEAP_PS, al igual que hemos comprobado
anteriormente. En la Figura 6.27 mostramos la tendencia de los resultados de los algoritmos
para valores de K 10000 segn el tiempo de respuesta requerido por K-CPC medido en
segundos.
0
18
36
54
72
90
1 10 100 1000 10000
Nmero de Pares
T
i
e
m
p
o

d
e

R
e
s
p
u
e
s
t
a

(
s
e
g
.
)
BAS EVN SML RECU_PS HEAP_PS

Figura 6.27 Tiempo de respuesta en segundos para K-CPC sobre los algoritmos
incrementales y no incrementales (recursivo e iterativo en su variante PS), utilizando un
buffer LRU de 512 pginas.
En la grfica podemos ver la diferencia que existe, en lo que concierne al tiempo de
respuesta, entre los algoritmos incrementales y los no incrementales para los valores de K,
pero en particular para K 10000. En los algoritmos incrementales, para valores de K
pequeos y medios (K 1000), la mejor alternativa es EVN (del 50% al 17% ms rpida que
Resultados experimentales y aplicacin
231
SML), pero cuando K se hacer mayor, SML resulta ser ms rpida (del 2% al 25%). Si
comparamos SML con las variantes no incrementales, la versin recursiva (RECU_PS)
resulta ser del 90% al 99% ms rpida para valores de K 10000, y la iterativa (HEAP_PS)
del 84% al 99%. Evidentemente, para K = 100000 las versiones no incrementales son mucho
ms rpidas, destacando que HEAP_PS tarda un 7% menos de tiempo que RECU_PS para
realizar la misma consulta.

Conclusiones
En general, la consulta de los pares ms cercanos es realmente una operacin costosa. De los
resultados obtenidos experimentalmente en esta seccin podemos extraer las siguientes
conclusiones:
1. En presencia de un buffer LRU, nuevamente la variante PS recursiva y no incremental
(RECU_PS) presenta los mejores resultados para el nmero de accesos a disco,
motivado fundamentalmente por la combinacin de la recursividad con buffer de
pginas gestionado con una poltica de reemplazo LRU. Comparando los algoritmos
iterativos, la mejor variante incremental (SML) es competitiva cuando K 100, pero
cuando K 1000 la alternativa no incremental (HEAP_STD) obtiene los mejores
resultados. Tambin debemos recordar que en ausencia de buffer, los algoritmos
iterativos, incremental (SML) y no incremental (HEAP_STD), fueron los mejores y con
el mismo nmero de operaciones de E/S necesarias para completar la consulta.
2. Si comparamos sobre los algoritmos iterativos, el nmero de pares que deben
almacenarse en la estructura de datos que se utiliza para evitar la recursividad (cola de
prioridad y montculo mnimo) y el nmero de inserciones en ella, que los algoritmos
incrementales requieren una mayor cantidad de ambos parmetros, ya que para ellos se
insertan todos los posibles pares de elementos que forman los R*-trees (MBR/MBR,
MBR/OBJ, OBJ/MBR y OBJ/OBJ), mientras que para los no incrementales slo se
insertan pares de la forma MBR/MBR. Adems, debemos indicar que los incrementales,
en base a estos dos parmetros, son competitivos cuando K 100, pero cuando K
1000 dejan de ser una alternativa razonable para la consulta.
3. Observando los resultados en base al tiempo de respuesta necesario para completar la
consulta y obtener los K pares ms cercanos, claramente las alternativas incrementales
no son competitivas respecto a las no incrementales (PS es la mejor variante para la
evaluacin de este parmetro), incluso cuando K es pequeo. Esto se debe
fundamentalmente al gasto adicional que hay que realizar para gestionar la cola de
prioridad (memoria principal y disco). Nuevamente, la variante recursiva (RECU_PS)
es la ms rpida cuando K 10000, pero cuando K 100000 la alternativa iterativa y
no incremental (HEAP_PS) proporciona los mejores resultados.



Captulo 6
232
6.7 Auto-CPC y Semi-CPC

Dos de las extensiones ms importantes de la consulta de los pares ms cercanos son las que
denominamos Auto-CPC y Semi-CPC. Auto-CPC es una extensin en el sentido de que los
dos conjuntos de objetos de entrada para la consulta son idnticos P = Q, con lo que sus R*-
trees tambin coincidirn, R
P
= R
Q
. Por otro lado, Semi-CPC tiene como caracterstica
principal que, dados los dos conjuntos de objetos P y Q, sta calcula para cada objeto de P el
objeto ms prximo en Q.

Evaluacin de resultados para Auto-K-CPC
En primer lugar vamos a estudiar el comportamiento de Auto-CPC sobre el conjunto de datos
(puntos) reales, utilizando como parmetros de evaluacin, el nmero de accesos a disco y el
tiempo de respuesta. En las Tablas 6.36 y 6.37 podemos observar las operaciones de E/S de
esta consulta (Auto-K-CPC) para las variantes ms representativas de los algoritmos
recursivos e iterativos, sin utilizar y utilizando un buffer LRU de 512 pginas (256 para cada
R*-tree). Por otro lado, en Figura 6.28, podemos observar la tendencia de la mejor variante
(STD) ante el nmero de accesos a disco recursiva e iterativa en presencia de un buffer LRU y
en ausencia del mismo.

RECU_SIM RECU_STD RECU_PS HEAP_SIM HEAP_STD HEAP_PS
1 23740 23732 23728 23728 23728 23728
10 23828 23812 23772 23728 23728 23728
100 24368 24312 24342 23748 23748 23748
1000 27678 27602 27620 24980 24980 24980
10000 38150 37492 40072 31372 31372 31372
100000 69730 67648 76094 51792 51792 51792
Tabla 6.36 Nmero de accesos a disco de las mejores variantes de los algoritmos recursivos
e iterativos, para Auto-K-CPC, en ausencia buffer.

RECU_SIM RECU_STD RECU_PS HEAP_SIM HEAP_STD HEAP_PS
1 10515 10515 10051 12588 12389 12337
10 10516 10516 10051 12526 12319 12393
100 10537 10539 10065 12536 12182 12177
1000 10584 10619 10110 13370 13248 13850
10000 10714 10829 10250 19564 19091 19308
100000 11147 11452 10520 38717 38511 38558
Tabla 6.37 Nmero de accesos a disco de las mejores variantes de los algoritmos recursivos
e iterativos, para Auto-K-CPC, utilizando un buffer LRU con 512 pginas.
De los datos procedentes de las Tablas 6.36 y 6.37 podemos comprobar que el mismo
comportamiento observado para K-CPC existe ahora para Auto-K-CPC, aunque con un mayor
nmero de accesos a disco al tener que detectar y despus descartar los pares iguales y los
simtricos, haciendo uso de una tabla hash (Auto_Tabla_Hash) asociada al montculo mximo
Resultados experimentales y aplicacin
233
que almacena el resultado (KMasCercanos). Tambin, podemos apreciar la influencia de un
buffer gestionado con una poltica de reemplazo de pgina LRU, sobre todo con las variantes
recursivas. Por ejemplo, para K = 1000 y RECU_STD, de utilizar un buffer de 512 pginas a
no utilizarlo se produce un ahorro del 62% en el nmero de accesos a disco.
La tendencia que se muestra en la Figura 6.28 es muy similar a la obtenida para K-CPC,
pudindose apreciar la diferencia que existe en el nmero de accesos a disco provocado por la
presencia de un buffer LRU.
10000
22000
34000
46000
58000
70000
1 10 100 1000 10000 100000
Nmero de Pares
A
c
c
e
s
o
s

a

D
i
s
c
o
RECU_STD (0) HEAP_STD (0) RECU_STD (512) HEAP_STD (512)

Figura 6.28 Nmero de accesos a disco de la variante STD en los algoritmos recursivo e
iterativo, para Auto-K-CPC, utilizando un buffer LRU con 512 pginas y en ausencia del
mismo.
El segundo parmetro a evaluar sobre Auto-K-CPC es el tiempo total de respuesta
(segundos) requerido para poder llevarla a cabo. Para ello, vamos a utilizar un buffer LRU de
512 pginas, de las que 256 se vinculan localmente a cada uno de los R*-trees. En la Tabla
6.38 podemos observar los segundos requeridos por las diferentes versiones de los algoritmos
Auto-K-CPC, destacando que RECU_PS es sensiblemente mejor que HEAP_PS para valores
de K menores o iguales que 10000, pero cuando K = 100000, HEAP_PS es un 40% ms
rpida.

RECU_SIM RECU_STD RECU_PS HEAP_SIM HEAP_STD HEAP_PS
1 6.69 17.93 1.17 8.28 19.94 1.85
10 7.17 18.33 1.19 7.75 20.43 1.87
100 7.77 19.03 1.27 8.19 20.72 1.94
1000 9.44 21.20 1.97 9.26 22.03 2.80
10000 18.35 29.67 7.76 15.90 29.42 8.01
100000 104.13 106.23 94.22 61.32 81.61 55.79
Tabla 6.38 Tiempo de respuesta en segundos para Auto-K-CPC sobre los algoritmos
recursivo e iterativo, utilizando un buffer LRU de 512 pginas (256 para cada uno de los
rboles).
Captulo 6
234
La Figura 6.29 refleja la tendencia de la mejor variante (PS) para optimizar el tiempo de
respuesta conforme se incrementa el valor de K. Como hemos podido comprobar en
anteriores experimentos sobre K-CPC, para Auto-K-CPC el comportamiento es muy similar.
Para K 10000 la mejor alternativa es RECU_PS, mientras que para K 100000, la variante
ms rpida es HEAP_PS.
0
20
40
60
80
100
1 10 100 1000 10000 100000
Nmero de Pares
T
i
e
m
p
o

d
e

R
e
s
p
u
e
s
t
a

(
s
e
g
.
)
RECU_PS HEAP_PS

Figura 6.29 Tiempo de respuesta en segundos para Auto-K-CPC sobre la variante PS de los
algoritmos recursivo e iterativo, utilizando un buffer LRU de 512 pginas.

Evaluacin de resultados para Semi-CPC
Una vez estudiada la extensin de la Auto-CPC, vamos a mostrar los resultados obtenidos de
realizar la Semi-CPC sobre el R*-tree que indexa puntos espaciales reales respecto a otro R*-
tree que hace lo propio con puntos reales movidos aleatoriamente y con la misma cardinalidad
(62556). Hemos adaptado las variantes SIM y STD, tanto del algoritmo recursivo como del
iterativo, para implementar las dos alternativas propuestas en el captulo 5 para Semi-CPC,
GlobalObjetos (GO) y GlobalTodos (GT). Para comparar las adaptaciones anteriores, se ha
implementado la forma ms intuitiva de llevar a cabo la Semi-CPC y que denominamos
R+CVP. sta consiste en recorrer el R*-tree R
P
(indexando al conjunto de objetos P) y
ejecutar por cada elemento en las hojas del mismo, una consulta del vecino ms prximo en el
R*-tree R
Q
(indexando al conjunto de objetos Q), tomando a ste como elemento de consulta.
La Tabla 6.39 muestra el nmero de accesos a disco en presencia de un buffer LRU de 512
pginas y sin l, para estas variantes de Semi-CPC.

R+CVP GO_RECU_SIM GT_RECU_SIM GT_RECU_STD GT_HEAP_SIM
B = 0 363142 964242 221806 159292 118300
B = 512 15328 48607 24605 21657 83530
Tabla 6.39 Nmero de accesos a disco para las adaptaciones GlobalObjetos (GO) y
GlobalTodos (GT) de los algoritmos recursivos e iterativos, junto con R+CVP, para la Semi-
CPC, sin utilizar y utilizando un buffer LRU con 512 pginas.
Resultados experimentales y aplicacin
235
De los datos de la tabla anterior se puede apreciar que esta consulta es bastante costosa
respecto al nmero de operaciones de E/S. En ausencia de buffer, GO_RECU_SIM es la
variante ms costosa y le sigue R+CVP, siendo la variante de la alternativa iterativa SIM de
GlobalTodos, GT_HEAP_SIM, la mejor de todas, con un 67% de ahorro con respecto a
R+CVP y del 88% en relacin a GO_RECU_SIM. En presencia de un buffer LRU de 512
pginas podemos apreciar nuevamente que la alternativa recursiva STD de GlobalTodos
(GT_RECU_STD) es la que obtiene un mayor beneficio de las extensiones de CPC, pero la
que obtiene los mejores resultados es R+CVP, que llega a tener un nmero de accesos del
29% menor que GT_RECU_STD. Esto se debe fundamentalmente a que, ejecutando un gran
nmero de consultas del vecino ms prximo sucesivamente (tantas como elementos de P)
sobre un R*-tree (R
Q
) y la existencia de numerosas pginas en un buffer LRU, es muy
probable que pginas muy accedidas de R
Q
se encuentren en dicho buffer, reduciendo
notablemente el nmero de operaciones de E/S para esta alternativa de Semi-CPC.
En lo que concierne al tiempo de respuesta, la Tabla 6.40 muestra los segundos empleados
en dar respuesta a la Semi-CPC con las citadas alternativas.

R+CVP GO_RECU_SIM GT_RECU_SIM GT_RECU_STD GT_HEAP_SIM
B = 0 22.56 178.99 70.13 62.43 52.51
B = 512 17.98 167.77 67.22 60.63 50.59
Tabla 6.40 Tiempo total de respuesta en segundos para las adaptaciones GlobalObjetos (GO)
y GlobalTodos (GT) de los algoritmos recursivos e iterativos, junto con R+CVP, para la Semi-
CPC, sin utilizar y utilizando un buffer LRU con 512 pginas.
Resulta interesante observar que R+CVP es la alternativa con menor tiempo de respuesta
requerido para realizar la consulta (un 64% ms rpida que GT_HEAP_SIM). Esto se debe
fundamentalmente a que no tiene que aplicar MinMaxDist entre pares de MBRs como s
deben hacerlo las extensiones GlobalTodos. Por otro lado, la variante GlobalObjetos es la que
ms tiempo requiere (casi 10 veces ms lenta que R+CVP), debido principalmente a la gran
cantidad de accesos a disco que tiene que emplear para realizar la consulta. Tambin podemos
apreciar que con la presencia de un buffer LRU, se reduce el tiempo de respuesta adems del
nmero de accesos a disco. Por ejemplo, para R+CVP supone un ahorro de aproximadamente
el 20%.

Conclusiones
La conclusin ms importantes que podemos extraer de este conjunto de experimentos para la
Auto-K-CPC y Semi-CPC es que las extensiones de los algoritmos para estas operaciones son
apropiadas. En particular, para la Auto-K-CPC, el tiempo de respuesta y el nmero de accesos
a disco necesario para completar la consulta en presencia de un buffer LRU hacen de esta
consulta bastante eficiente en base a estos dos parmetros, sobre todo para el algoritmo
recursivo en su variante PS (RECU_PS), sin olvidar que para K 100000, HEAP_PS fue la
variante ms rpida. Por otro lado, para Semi-CPC, la extensin del algoritmo iterativo para
GlobalTodos y en ausencia de buffer la hacen bastante competitiva, pero cuando tenemos un
Captulo 6
236
buffer LRU de un nmero razonable de pginas, la alternativa R+CVP es la que proporciona
los mejores resultados.

6.8 Conclusiones de la experimentacin

En este captulo se han descrito los aspectos ms relevantes del trabajo experimental
desarrollado como justificacin de las aportaciones de esta tesis. Debemos destacar tambin
que no es objetivo de este trabajo de investigacin exponer la implementacin de los
algoritmos, ni las de todas las estructuras de datos empleadas, que han sido muchas, ya que
implicara un considerable incremento en extensin de esta tesis.
Con el principal objetivo de evaluar la utilidad de nuestras propuestas en el entorno de las
bases de datos espaciales y de encontrar la mejor alternativa algortmica para dar respuesta a
la consulta del par ms cercano o para cualquiera de sus extensiones en funcin de
determinados parmetros, hemos desarrollado un amplio estudio comparativo. Esta labor de
experimentacin abarca desde la definicin y generacin de las distintas bateras de pruebas
para los diferentes casos de estudio hasta el posterior tratamiento y evaluacin de los
resultados obtenidos.
Las conclusiones ms importantes que hemos extrado de los experimentos son las
siguientes:
1. Respecto a la evaluacin experimental sobre K-CPC y CPC como un caso especial,
obtenemos que:
1.1. En ausencia de buffer, la mejor alternativa respecto al nmero de accesos a disco es
el algoritmo branch-and-bound iterativo, utilizando un montculo mnimo global para
evitar la recursividad y combinado con una estrategia de bsqueda de primero el
mejor (HEAP). Pero cuando incluimos buffers (path-buffer y buffer LRU local a
cada rbol) los algoritmos recursivos son los que presentan un mayor ahorro en
operaciones de E/S, debido fundamentalmente a la combinacin de la recursividad
(recorrido en profundidad) con la gestin del buffer con una poltica de reemplazo
LRU (da prioridad a las pginas ms recientemente referenciadas).
1.2. Respecto al tiempo global requerido para realizar las consultas, la variante PS
(optimizacin utilizando la tcnica de Barrido del Plano) recursiva (RECU) de
nuestros algoritmos branch-and-bound es la ms rpida, aunque para valores de K
muy grandes su homnima (PS) del algoritmo iterativo (HEAP) tiene un mejor
comportamiento ante este parmetro.
1.3. Aplicar la mtrica MinMaxDist en CPC y MaxMaxDist en K-CPC no supone un
ahorro significativo respecto al nmero de accesos a disco para nuestros algoritmos
branch-and-bound. Adems, el clculo de estas mtricas y el procesamiento adicional
necesario sobre estructuras de datos adicionales supone un gasto extra de CPU,
haciendo que los algoritmos sean ms lentos.
Resultados experimentales y aplicacin
237
1.4. Los algoritmos iterativos requieren estructuras de datos adicionales para evitar la
recursividad, y conforme crece el valor de K, la cantidad necesaria de estos recursos
aumenta. Una forma de reducirlos es utilizar la mtrica MaxMaxDist (con un
montculo mximo adicional) y una poltica para el tratamiento de empates (los
MBRs que forman el par tienen el mismo valor de MinMinDist) adecuada, aunque
todo esto requiere de un gasto extra de tiempo de clculo.
1.5. Cuando tenemos R*-trees con diferentes alturas, la tcnica de Fijar las Hojas es la
mejor para el algoritmo recursivo, mientras que Fijar la Raz lo es para la versin
iterativa. Adems, la versin iterativa (HEAP) con Fijar la Raz es la que
proporciona los mejores resultados (nmero de accesos a disco y tiempo de
respuesta) cuando K es muy grande, siendo en los otros casos la versin recursiva
(RECU) combinada con la tcnica Fijar las Hojas la que proporciona los mejores
resultados.
1.6. Si tenemos en cuenta el factor de solape entre las reas que cubren los conjuntos de
objetos que intervienen en la consulta, hemos visto que cuando ste crece, el nmero
de accesos a disco tambin crece, motivado fundamentalmente por la potencial
existencia de un nmero mayor de pares de MBRs con MinMinDist igual a 0 muy
prximos a este valor.
2. Si comparamos nuestros algoritmos no incrementales con los incrementales respecto a
K-CPC llegamos a la conclusin de que la variante Simultaneous de estos ltimos es la
nica competitiva para valores de K pequeos, pero nunca consigue aproximarse a los
resultados de nuestros algoritmos recursivos en lo que respecta al nmero de accesos a
disco y al tiempo de respuesta cuando K tiene valores medios y grandes. Adems, si
comparamos estos algoritmos con nuestro iterativo y no incremental (HEAP), la
cantidad de recursos necesarios para evitar la recursividad y procesar la consulta
correctamente es considerablemente menor. Tambin debemos indicar que los recursos
requeridos por los algoritmos incrementales son tan elevados al considerar valores
grandes de K, para que el usuario pueda disponer de parte del resultado durante la
ejecucin de los mismos, siendo esta su principal ventaja.
3. Las extensiones de nuestros algoritmos para llevar a cabo la Auto-CPC y la Semi-CPC
son apropiadas, en particular para la Auto-CPC, donde el tiempo de respuesta y el
nmero de accesos a disco en presencia de un LRU buffer hacen de esta consulta
bastante eficiente, sobre todo para el algoritmo recursivo (RECU) en su variante PS
(Barrido del Plano), sin olvidar que para valores de K muy grandes, la variante PS del
algoritmo iterativo (HEAP) fue la ms rpida. En cambio, para Semi-CPC, la extensin
de nuestros algoritmos (recursivos e iterativos) para GlobalObjetos y GlobalTodos,
adems de requerir muchos recursos en memoria principal, obtiene peores resultados
que R+CVP (combina un recorrido en profundidad en el primer rbol con una consulta
del vecino ms prximo sobre el segundo) cuando tenemos un buffer LRU de un
nmero razonable de pginas.
Como conclusin final podemos decir que nue