Algoritmos para el Procesamiento de Consultas …acorral/acorralTesis.pdfUNIVERSIDAD DE ALMERÍA...

UNIVERSIDAD DE ALMERÍA

Departamento de Lenguajes y Computación

TESIS DOCTORAL

Algoritmos para el Procesamiento de Consultas Espaciales utilizando R-trees. La Consulta de

los Pares Más Cercanos y su Aplicación en Bases de Datos Espaciales

ANTONIO LEOPOLDO CORRAL LIRIA

Almería, Enero 2002

UNIVERSIDAD DE ALMERÍA


TESIS DOCTORAL



Directores: Autor:

Dr. Yannis Manolopoulos Dr. José Samos Jiménez Antonio Leopoldo Corral Liria

UNIVERSIDAD DE ALMERÍA ESCUELA POLITÉCNICA SUPERIOR




Memoria presentada por Antonio Leopoldo Corral Liria para optar al grado de Doctor en Informática por la Universidad de Almería

Directores: Dr. Yannis Manolopoulos

Dr. José Samos

Almería, 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 más sincero agradecimiento a Yannis Manolopoulos, director de esta tesis, por la inestimable y generosa atención 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 evolución sufrida en mi carrera como investigador. También, mi gratitud a José Samos, director también de esta tesis, por su apoyo, generosidad y dedicación en la preparación de esta memoria.

Agradezco también la ayuda y colaboración prestada por Michalis Vassilakopoulos y Yannis Theodoridis, cuyas ideas y consejos me han permitido mejorar considerablemente esta tesis. Su visión 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 investigación. También doy las gracias a Jesús Almendros, José Jesús Fernández y Julián García por su sentido crítico y perfeccionista, de ayuda vital para la organización y elaboración de esta memoria.

A Manuel Torres, mi compañero de despacho, con quien he compartido más de cerca las alegrías 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 difíciles. A Samuel Túnez, 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 Salónica.

Debo extender mi gratitud a todos los compañeros del Departamento de Lenguajes y Computación de la Universidad de Almería, que me animaron en todo momento a sacar adelante esta tesis y a hacer más llevadera mi estancia en Salónica. Antonio Becerra, Luis Iribarne, Rosa Ayala, Rafael Guirado, Francisco Rodríguez, Manuel Berenguel, José Carlos Moreno, Joaquín Cañadas, Francisco Guil, José Rafael García, Daniel Landa y Jordi Rodríguez. A todos ellos les agradezco su sinceridad y amabilidad conmigo.

También, 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 económico recibido para poder realizar la estancia en Salónica. Y al proyecto DAMOCIA, la posibilidad de disfrutar de una beca de investigación en la Universidad de Almería.

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 compresión 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 cariño con el que siempre me han tratado y que durante estos años no les he podido corresponder.

Mi último y más profundo sentimiento de gratitud se lo dedico a Rosa, mi mujer, cuyo amor y cariño 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 información geográfica), CAD (diseño asistido por ordenador), planificación 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 relación que existe entre dichos datos. Para gestionar de forma eficiente y rápida este gran volumen de datos se precisa del uso de métodos de acceso. El procesamiento de consultas sobre métodos de acceso es un tema de investigación 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 informático estos datos espaciales se representan por puntos, líneas, polígonos, 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 cuál es la relación 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 relación espacial es la relación de cercanía, que representa el grado de proximidad entre los objetos espaciales, por ejemplo, la consulta del vecino más próximo encuentra, entre un conjunto de objetos espaciales, el objeto más próximo a uno previamente dado. La consulta basada en la relación de cercanía entre dos conjuntos de objetos espaciales y que vamos a estudiar en esta tesis, la vamos a denominar consulta de los pares más cercanos.

Branch-and-bound (ramificación y poda) es una técnica general de diseño de algoritmos utilizada para buscar la solución óptima de un determinado problema. La idea principal consiste en dividir el problema inicial en subproblemas parciales de tamaño más pequeño a los que aplicamos heurísticas de poda que permiten descartar el espacio de soluciones del problema que no conduce a la solución óptima. Esta técnica se suele utilizar en el diseño de algoritmos para consultas en bases de datos espaciales, recorriendo los métodos de acceso espaciales y calculando cotas relativas a soluciones parciales para limitar el número de soluciones completas a examinar. En nuestro caso, los algoritmos que diseñaremos estarán basados en esta técnica y utilizarán heurísticas de poda basadas en distancias para acotar el espacio de búsqueda.

Resumen

iv

En esta tesis estudiamos algoritmos branch-and-bound y aplicamos técnicas de optimización sobre ellos para encontrar, dados dos conjuntos de objetos espaciales, los pares de objetos espaciales más cercanos, perteneciendo cada elemento del par a un conjunto diferente. Dichos conjuntos de objetos espaciales se encuentran indexados en R-trees (método de acceso derivado del B-tree para gestionar información multidimensional), que son estructuras de datos arbóreas basadas en rectángulos 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 arbóreas, ya que aplicando heurísticas de poda basadas en propiedades intrínsecas a las consultas podemos obtener el resultado en tiempo logarítmico y empleando un reducido número de operaciones de E/S.

Los únicos trabajos que abordan la consulta de los pares más 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 número de pares más cercanos deseado antes de iniciar la consulta. Sobre estos últimos algoritmos aplicamos técnicas de optimización para mejorarlos desde el punto de vista del tiempo de respuesta y del número de accesos a disco. Tratamos de reducir el número de operaciones de E/S y el tiempo de respuesta para satisfacer las necesidades de los usuarios, que requieren respuestas rápidas a consultas complejas. En nuestro caso, vamos a aplicar estos algoritmos a conjuntos de objetos espaciales (puntos) de dimensión dos, pero su extensión 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 más cercano entre dos conjuntos de objetos en el espacio Euclídeo k-dimensional, donde cada elemento del par pertenece a un conjunto diferente. Esta nueva consulta se compara desde el punto de vista algorítmico con la consulta del vecino más próximo y con el join espacial. También, se presentan las funciones de distancia entre pares de MBRs como base de las heurísticas de poda aplicadas en algoritmos branch-and-bound recursivos e iterativos.

2. Se presentan las heurísticas de poda que aplicamos en algoritmos branch-and-bound, siguiendo diferentes estrategias de búsqueda (en profundidad, primero el mejor, y en anchura combinada con primero el mejor), para resolver la consulta del par más cercano. Con el objetivo de reducir el número de accesos a disco y el tiempo de respuesta que son de gran importancia en la eficiencia de estos algoritmos, se definen e implementan técnicas de optimización, como por ejemplo, el Barrido del Plano.

3. Una vez establecidos los algoritmos branch-and-bound para llevar a cabo la consulta del par más cercano, se presentan varias extensiones del mismo junto con los detalles de implementación para que éstos sean lo más 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 más cercanos (K-CPC), (4) obtener todos o los K pares más cercanos en un rango de distancia [Dist_Min, Dist_Max], (5) variantes para

Resumen

v

la consulta del par más lejano (CPL) y de los K pares más lejanos (K-CPL), (6) la Auto-consulta y la Semi-consulta de los pares más 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 más cercanos presentados en esta tesis han sido evaluados sobre objetos espaciales (puntos) reales y sintéticos, con el objetivo de medir y probar la eficiencia de los mismos. Se han evaluado fundamentalmente respecto al número de accesos a disco y tiempo total de respuesta requerido, aunque también se ha tenido en cuenta para los algoritmos iterativos los recursos requeridos para evitar la recursividad. También 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 evaluación de las extensiones más 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

Capítulo 1 INTRODUCCIÓN ....................................................................................... 1

1.1 Introducción ..................................................................................................... 1 1.2 Ámbito y motivación ....................................................................................... 3 1.3 Objetivos de la tesis ....................................................................................... 4 1.4 Contribuciones ................................................................................................ 5 1.5 Descripción del contenido ............................................................................. 5

Capítulo 2 MÉTODOS DE ACCESO ESPACIALES BASADOS EN MBRs. R*-TREE ..................................................................................................... 9

2.1 Introducción ..................................................................................................... 9 2.2 Métodos de acceso multidimensionales. Una revisión ................................... 10

2.2.1 Métodos de acceso multidimensionales basadas en memoria principal ...... 11 2.2.2 Métodos de acceso basados en almacenamiento secundario .................... 12

2.2.2.1 Métodos de acceso a puntos ............................................................... 13 2.2.2.2 Métodos de acceso espaciales .......................................................... 14

2.3 Modelo de organización de índices basados en MBRs en el espacio de datos k-dimensional ....................................................................................... 16

2.4 La familia de los R-trees k-dimensionales como método 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 Características principales del R*-tree ...................................................... 33 2.6.3 Algoritmos para el mantenimiento de un R*-tree ....................................... 35

2.6.3.1 Algoritmo de inserción .................................................................... 35 2.6.3.2 Algoritmo de borrado ......................................................................... 40 2.6.3.3 Algoritmo de búsqueda .................................................................... 41

2.6.4 Algoritmos para el procesamiento de consultas utilizando R*-trees como método 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 más próximo ................ 46 2.6.4.2.4 Algoritmos para determinar el join espacial .............................. 49

2.7 Conclusiones ..................................................................................................... 57 Capítulo 3 CONSULTAS DE LOS PARES MÁS CERCANOS .............................. 59

3.1 Introducción ..................................................................................................... 59 3.2 La consulta del par más cercano y su extensión a los K pares más

cercanos .......................................................................................................... 60 3.2.1 Métricas ..................................................................................................... 60 3.2.2 El par más cercano de un conjunto de puntos ............................................ 62

3.2.3 Definición de la consulta del par más cercano y su extensión a los K pares más cercanos ................................................................................................ 64

3.2.4 Ejemplos de aplicación de las consultas de los pares más cercanos sobre datos espaciales ........................................................................................... 66

3.3 Las consultas join y el vecino más próximo, como base para las consultas de los pares más cercanos ............................................................................. 70

3.3.1 Join utilizando R*-trees ............................................................................. 70 3.3.2 La consulta del par más cercano utilizando R*-trees ................................... 71

3.4 Métricas entre pares de MBRs para el procesamiento de las consultas de los pares más cercanos .................................................................................. 76

3.5 Conclusiones ..................................................................................................... 90

Capítulo 4 ALGORITMOS PARA LA REALIZACIÓN DE LA CONSULTA DEL PAR MÁS CERCANO UTILIZANDO R*-TREES .................... 93

4.1 Introducción ..................................................................................................... 93

4.2 Primeras aproximaciones para dar solución a la consulta del par más 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 más próximo 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 montículo ................ 98 4.2.4.1 Montículos ....................................................................................... 99 4.2.4.2 Algoritmo iterativo utilizando un montículo ....................................... 102


xi

4.3 Algoritmos branch-and-bound para determinar el par más 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 más cercano ....................................................................................... 108 4.3.3 Reglas de poda basadas en distancias para los algoritmos branch-and-

bound que determinan el par más cercano ................................................. 111 4.4 Algoritmos branch-and-bound recursivos para encontrar el par más

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 técnica de Barrido del Plano .............................................................................................................. 118

4.5 Algoritmos branch-and-bound iterativos utilizando un montículo para encontrar el par más cercano ......................................................................... 124

4.5.1 Algoritmo branch-and-bound iterativo MINMINDIST utilizando un montículo ..................................................................................................... 124

4.5.2 Algoritmo branch-and-bound iterativo MINMAXDIST_MINMINDIST utilizando un montículo ............................................................................. 126

4.5.3 Algoritmo branch-and-bound iterativo MINMAXDIST_MINMINDIST Ordenado utilizando un montículo ............................................................... 127

4.5.4 Algoritmo branch-and-bound iterativo utilizando la técnica de Barrido del Plano y un montículo .................................................................................. 130

4.5.5 Algoritmo branch-and-bound iterativo basado en un recorrido en anchura y utilizando una lista de montículos ............................................................... 132

4.6 Comparativa con otros algoritmos que determinan el par más cercano utilizando R*-trees ....................................................................................... 135

4.7 Conclusiones ..................................................................................................... 137

Capítulo 5 EXTENSIONES DE LOS ALGORITMOS Y DETALLES DE IMPLEMENTACIÓN ............................................................................. 139

5.1 Introducción ..................................................................................................... 139 5.2 Tratamientos para R*-trees con diferentes alturas ................................... 140

5.3 Extensión de los algoritmos para el caso en que las hojas de los R*-trees almacenen MBRs de los objetos .................................................................... 147

5.4 Extensión de los algoritmos para la consulta de los K pares más cercanos. 149 5.5 Extensión de los algoritmos para obtener los K pares más cercanos en un

rango de distancia [Dist_Min, Dist_Max] ...................................................... 157 5.6 Extensión de los algoritmos para realizar la consulta del par más lejano y

de los K pares más lejanos ............................................................................. 160 5.7 Auto-consulta de los pares más cercanos (Auto-CPC) .............................. 163 5.8 Semi-consulta de los pares más cercanos (Semi-CPC) .............................. 166 5.9 Conclusiones ..................................................................................................... 169


xii

Capítulo 6 RESULTADOS EXPERIMENTALES Y APLICACIÓN .................... 171

6.1 Introducción ..................................................................................................... 171 6.2 Resultados experimentales para CPC y K-CPC ............................................ 172

6.2.1 Objetivos ..................................................................................................... 172 6.2.2 Definición de los experimentos .................................................................... 173 6.2.3 Presentación y análisis de resultados .......................................................... 175 6.2.4 Conclusiones ................................................................................................ 194

6.3 Utilización de R*-trees con diferentes alturas ............................................ 195 6.4 Efecto del porcentaje de solape entre los conjuntos de datos .................... 202 6.5 Inclusión de un buffer de páginas con una política de reemplazo LRU .. 212 6.6 Comparación con la alternativa incremental ................................................. 224 6.7 Auto-CPC y Semi-CPC .................................................................................. 232 6.8 Conclusiones de la experimentación ............................................................... 236

Capítulo 7 CONCLUSIONES Y TRABAJO FUTURO ............................................ 239

7.1 Conclusiones ..................................................................................................... 239 7.2 Líneas de trabajo futuro .................................................................................. 242

REFERENCIAS .......................................................................................................... 245 APÉNDICE A .............................................................................................................. 259

xiii

Índice de Figuras

2.1 Ejemplo de un k-d-tree (orden de inserción: p1, p2, p3, p4, p5, p6) ................ 11 2.2 Ejemplo de un B-tree (orden de inserción: 8, 5, 1, 7, 3, 12, 9, 8) ..................... 14

2.3 Ejemplo en una, dos y tres dimensiones de un n-rectángulo definido por dos puntos ............................................................................................................... 19

2.4 MBRs de uno o más objetos ............................................................................. 22 2.5 Un ejemplo de R-tree ....................................................................................... 30

2.6 Alternativas para la división de un nodo que ha excedido su capacidad máxima ............................................................................................................... 31

2.7 Un ejemplo de R*-tree ....................................................................................... 34 2.8 Solape de R en N ................................................................................................ 35 2.9 Inserción del MBR R9 ....................................................................................... 38

2.10 Distribución de los MBRs y el R*-tree asociado después de insertar el MBR R9 ................................................................................................................... 39

2.11 Búsqueda 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 R1 y R2 en E(2) 74 3.3 Aplicación de la estrategia de poda para encontrar el vecino más próximo ...... 75 3.4 MinMinDist(Ri, Rj) entre dos MBRs en E(2) ...................................................... 77 3.5 Propiedad de MinMinDist en una dimensión 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(Ri, Rj) entre dos MBRs en E(2) .............................. 83

3.9 Distancias entre las caras a1 y b1 para calcular MinimaMaximaDistancia(R1, R2) ................................................................................................................... 83

3.10 MinimaMaximaDistancia(R1, R2) y MinMaxDist(R1, R2) entre dos MBRs en E(2) ................................................................................................................... 87

3.11 MaxMaxDist(Ri, Rj) entre dos MBRs en E(2) ...................................................... 88 3.12 MinMinDist, MinMaxDist y MaxMaxDist entre dos MBRs R1 y R2 en E(2) ...... 90 4.1 Árbol binario esencialmente completo .......................................................... 99 4.2 Ejemplo de montículo ....................................................................................... 100 4.3 Representación de un montículo como estructura de datos .............................. 101 4.4 Aplicación de las estrategias de poda para encontrar el par más 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 técnica de Barrido del Plano ........... 119

Índice de figuras

xiv

4.7 Efecto de la selección 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 montículos mínimos organizada por niveles ........... 132 5.1 Posibles casos para dos R*-trees (RP y RQ) con diferentes alturas ..................... 140

5.2 Modelos de organización para almacenar objetos en un R*-tree según [BrK94a, BHK+93] ............................................................................................ 148

5.3 Estructuras de datos adicionales para el procesamiento de los K pares más cercanos (K-CPC) sobre algoritmos recursivos ................................................. 149

5.4 Estructuras de datos adicionales para el procesamiento de los K pares más cercanos (K-CPC) sobre algoritmos iterativos ................................................. 154

5.5 Tabla hash organizada por listas enlazadas asociada a un montículo máximo de pares de MBRs (MMMD), utilizando como clave para la organización de la misma, la métrica MaxMaxDist .................................................................... 155

5.6 Estructuras de datos adicionales para obtener los K pares más cercanos que están 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 montículo mínimo de pares de puntos (KMasCercanos), utilizando como clave de ordenación la distancia Euclídea 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 = número de MBRs en el R*-tree RP ........... 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 técnicas de Fijar las Hojas (FH) y Fijar la Raíz (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 Número 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 indexación 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 estándar de una base de datos para el procesamiento de consultas 213 6.16 Esquema de buffer Local para la consulta de los pares más cercanos ................ 215

6.17 Estructura de datos de un buffer de páginas 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 páginas de tamaño variable al aplicar el algoritmo recursivo (RECU_STD) y el iterativo (HEAP_STD) para obtener el par más cercano (CPC) ....................................................................................... 218

6.20 Número de accesos a disco del algoritmo recursivo (RECU_STD) para K-CPC utilizando un buffer de páginas LRU de tamaño variable ......................... 219

6.21 Número de accesos a disco del algoritmo iterativo (HEAP_PS) para K-CPC utilizando un buffer de páginas LRU de tamaño variable .............................. 220

6.22 Porcentaje de ahorro para K-CPC con el algoritmo recursivo (RECU_STD), variando el tamaño 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 tamaño del buffer (B > 0) con respecto a B = 0 .............................. 221

6.24 Número de accesos a disco para K-CPC utilizando los algoritmos, recursivo (RECU_STD) e iterativo (HEAP_PS), fijando el tamaño del buffer (B = 512) y tomando como parámetro variable el valor de K ............................................ 222

6.25 Esquema de buffer Global para la consulta de los pares más cercanos ........... 223

6.26 Número 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 páginas ............................................ 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 páginas .......................................................... 230

6.28 Número de accesos a disco de la variante STD en los algoritmos recursivo e iterativo, para Auto-K-CPC, utilizando un buffer LRU con 512 páginas 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 páginas. 234

xvii

Índice de Tablas

2.1 Clasificación general de los métodos de acceso basados en almacenamiento secundario .......................................................................................................... 12

2.2 Clasificación de los métodos de acceso más representativos de la familia del R-tree k-dimensional ....................................................................................... 24

2.3 Clasificación de los métodos de join espacial ................................................. 52

4.1 Comparativa entre algoritmos iterativos, incrementales y no incrementales para obtener el par más cercano utilizando R*-trees como método de indexación .......................................................................................................... 136

6.1 Número de accesos a disco para CPC ............................................................... 176 6.2 Número de accesos a disco para K-CPC .......................................................... 177

6.3 Tamaño máximo del montículo principal para K-CPC (HEAP), considerando y sin considerar MaxMaxDist ......................................................................... 179

6.4 Número de inserciones en el montículo principal para K-CPC (HEAP), considerando y sin considerar MaxMaxDist ...................................................... 179

6.5 Número 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 Tamaño máximo del montículo, considerando y sin considerar un tratamiento de empates .......................................................................................................... 188

6.7 Número de inserciones en el montículo principal, considerando y sin considerar un tratamiento de empates ............................................................... 189

6.8 Tamaño máximo del montículo principal, para HEAP y BFT ......................... 189 6.9 Número de inserciones en el montículo 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 Número de accesos a disco para CPC sobre R*-trees con diferentes alturas .. 196 6.15 Número 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 Tamaño máximo del montículo para CPC utilizando el algoritmo iterativo

HEAP, considerando y sin considerar técnicas de optimización ..................... 198

Índice de tablas

xviii

6.17 Número de inserciones en el montículo para CPC utilizando el algoritmo

iterativo HEAP, considerando y sin considerar técnicas de optimización ...... 198 6.18 Tamaño máximo del montículo para K-CPC empleando el algoritmo iterativo

HEAP, utilizando Fijar las Hojas (FH) y Fijar la Raíz (FR) ......................... 199 6.19 Número de inserciones en montículo para K-CPC empleando el algoritmo

iterativo HEAP, utilizando Fijar las Hojas (FH) y Fijar la Raíz (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 Número de accesos a disco para CPC sobre R*-trees procedentes de la

indexación de puntos reales y reales movidos aleatoriamente ......................... 203

6.23 Número de accesos a disco para CPC, utilizando R*-trees procedentes de la indexación de puntos sintéticos generados aleatoriamente y siguiendo una distribución uniforme ....................................................................................... 203

6.24 Tiempo de respuesta en segundos para CPC, sobre R*-trees procedentes de la indexación 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 indexación 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 Número de accesos a disco y porcentaje de ahorro del algoritmo recursivo (RECU_STD) respecto del iterativo (HEAP_STD) para CPC, utilizando un buffer de páginas de tamaño variable (0 ≤ B ≤ 1024) y gestionado con una política LRU ..................................................................................................... 218

6.28 Número de accesos a disco del algoritmo recursivo (RECU_STD) para K-CPC utilizando un buffer de páginas LRU de tamaño variable (0 ≤ B ≤ 1024). 219

6.29 Número de accesos a disco del algoritmo iterativo (HEAP_PS) para K-CPC utilizando un buffer de páginas LRU de tamaño variable (0 ≤ B ≤ 1024) ...... 220

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

6.31 Número 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 Número 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 páginas (B = 512) .............................. 227

6.33 Número máximo 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 Número de pares insertados en la cola de prioridad de los algoritmos incrementales y en el montículo mínimo 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 indexación de puntos reales y reales movidos aleatoriamente, y utilizando un buffer LRU de 512 páginas ........... 230

6.36 Número de accesos a disco de las mejores variantes de los algoritmos recursivos e iterativos, para Auto-K-CPC, en ausencia buffer ......................... 232

6.37 Número de accesos a disco de las mejores variantes de los algoritmos recursivos e iterativos, para Auto-K-CPC, utilizando un buffer LRU con 512 páginas ............................................................................................................... 232

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

6.39 Número 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 páginas ............................................................................................................... 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 páginas ............................................................................................................... 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 más cercanos basado en un recorrido en anchura utilizando una lista de montículos mínimos siguiendo en cada uno de ellos una estrategia de búsqueda con una función de selección de primero el mejor

BRU Algoritmo para encontrar los pares más cercanos, sin tener en cuenta ningún criterio de poda

CA Consulta de Adyacencia CAD Diseño Asistido por Ordenador CCu Consulta de Cubrimiento CE Consulta Exacta CIn Consulta de Inclusión CLP Consulta para la Localización de un Punto CPC Consulta del Par más Cercano CPL Consulta del Par más Lejano CR Consulta en Rango CS Consulta de Solape CVP Consulta del Vecino más Próximo EVN Variante Evenly de los algoritmos incrementales EXH Variante de los algoritmos branch-and-bound para encontrar los pares más

cercanos, utilizando sólo la heurística de poda basada en MinMinDist FH Fijar las Hojas para el tratamiento de R*-trees con diferentes alturas FR Fijar la Raíz para el tratamiento de R*-trees con diferentes alturas GIS Sistemas de Información Geográfica GO Variante GlobalObjetos para Semi-CPC GT Variante GlobalTodos para Semi-CPC HEAP Algoritmo branch-and-bound iterativo para encontrar los pares más cercanos

utilizando un montículo mínimo global con una estrategia de búsqueda basada en una función de selección de primero el mejor

JE Join Espacial K-CPC Consulta de los K Pares más Cercanos K-CPL Consulta de los K Pares más Lejanos K-CVP Consulta de los K Vecinos más Próximos LRU Last Recently Used. Política de reemplazo de página que sustituye la página

menos recientemente utilizada

Glosario de abreviaciones

xxii

MAE Métodos de Acceso Espaciales MAP Métodos de Acceso a Puntos MaxDist Función que representa la máxima distancia de un punto a un MBR MaxMaxDist Función que representa la máxima distancia que hay entre dos MBRs MBR Minimum Bounding Rectangle. Mínima 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 Función que representa la mínima distancia de un punto a un MBR MinMaxDist Función que representa la mínima de todas las máximas distancias entre las

caras paralelas más próximas de dos MBRs para cada una de las dimensiones. También, representa el mínimo valor de todas las máximas distancias entre un punto y un MBR sobre cada una de las dimensiones

MinMinDist Función que representa la mínima distancia que hay entre dos MBRs PS Variante de los algoritmos branch-and-bound para encontrar los pares más

cercanos, utilizando la técnica del barrido del plano RECU Algoritmo branch-and-bound recursivo para encontrar los pares más

cercanos siguiendo una estrategia de búsqueda en profundidad R+CVP Algoritmo que aplica un recorrido en profundidad en un R*-tree combinado

con una consulta del vecino más próximo 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 más próximos en otro R*-tree SIM Variante de los algoritmos branch-and-bound para encontrar los pares más

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 más

cercanos, ordenando en base a MinMinDist en una lista local todos los posibles pares de MBRs procedentes de la combinación de dos nodos internos

STM Variante de los algoritmos branch-and-bound para encontrar los pares más cercanos, ordenando en base a MinMinDist en un montículo mínimo local todos los posibles pares de MBRs procedentes de la combinación de dos nodos internos

SGBD Sistema de Gestión de Base de Datos SGBDE Sistemas de Gestión de Bases de Datos Espaciales

1

Capítulo 1

INTRODUCCIÓN

1.1 Introducción

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 economía, lo que hace a las empresas manejar grandes cantidades de información para facilitar la toma de decisiones de forma rápida. Por ello, las aplicaciones actuales de bases de datos tales como GIS (sistemas de información geográfica), CAD (diseño 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 información de naturaleza espacial y ofrecer un lenguaje de consulta para su manipulación [Güt94]. Dicha información se representa mediante un modelo de datos espacial, como por ejemplo el propuesto en [ArS91].

En un sistema informático los datos espaciales se representan por puntos, líneas, polígonos, 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 información geográfica (GIS), diseño 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: planificación urbana, gestión de recursos, modelado ambiental, etc. [Sam90b].

Uno de los principales objetivos de un sistema de gestión de bases de datos es proporcionar métodos de acceso y algoritmos eficientes para el procesamiento de consultas [Güt94]. Para aumentar el rendimiento de dicho sistema (evaluado principalmente respecto al tiempo de

Capítulo 1

2

respuesta y número de accesos a disco) surgen los métodos de acceso [GaG98]. Los índices unidimensionales (estructuras de datos de clave única) más 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 información multidimensional se le conoce con el nombre de familia de R-trees (estructuras de datos arbóreas basadas en rectángulos 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 están el R-tree original [Gut84], R+-tree [SRF87], R*-tree[BKS+90], X-tree [BKK96], etc.

Para aumentar el rendimiento en la recuperación de los objetos espaciales se pueden definir índices espaciales. Dichos índices representan la ubicación de los objetos espaciales que están almacenados en la base de datos. Sin embargo, para simplificar el manejo de dichos índices se suele utilizar algún tipo de aproximación de los objetos espaciales. El mínimo rectángulo envolvente o MBR de esos objetos espaciales es la aproximación más utilizada [BKS93b, BrK94b]. Dichos MBRs representan la clave de indexación 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 métodos de acceso que ha demostrado ser muy eficiente sobre datos espaciales, mejorando notablemente al R-tree original [Gut84]. El procesamiento eficiente de consultas sobre métodos 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 optimización de las estructuras de datos que las soportan.

La característica principal que hace de un sistema de base de datos espacial una herramienta potente es su capacidad de procesar datos espaciales, incluso más que la representación y almacenamiento de los mismos [YuM98]. La forma más eficiente de gestionar dichos datos es responder a consultas relacionadas con propiedades espaciales. Las consultas espaciales más 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 están dentro de una región definida por un rango [Sam90a].

3. Consulta del vecino más próximo. Ésta es una consulta espacial que busca, entre un conjunto de objetos espaciales, el objeto espacial más próximo a uno previamente dado. Si generalizamos esta consulta, obtenemos los K objetos más próximos al objeto espacial consulta (los K vecinos más próximos) [RKV95].

4. Join espacial. Este tipo de consulta tiene como entrada dos o más conjuntos de objetos espaciales y determina pares (o tuplas en el caso de tener más de dos conjuntos) de objetos espaciales que verifican una determinada propiedad espacial. Por ejemplo, el join espacial que actúa 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 relación de cercanía, la consulta de los pares más cercanos, que consiste en devolver, dados dos conjuntos de objetos espaciales, los pares de objetos más cercanos entre sí, donde cada elemento del par pertenece a un conjunto diferente.

Introducción

3

En este capítulo de introducción se pretende ofrecer una visión global del entorno del problema y las soluciones propuestas como aportación principal de esta tesis, y se organiza como sigue. En el primer apartado se enuncia la motivación que ha guiado el planteamiento de esta tesis y el ámbito donde se ubica. A continuación, planteamos los objetivos perseguidos con este trabajo de investigación. En tercer lugar enumeramos las contribuciones más representativas de esta tesis. Y por último, se presenta el contenido de la misma de forma resumida.

1.2 Ámbito y motivación

Esta tesis se ubica en el contexto del proyecto TMR europeo CHOROCHRONOS (ERBFMRXCT960056). CHOROCHRONOS (Espacio-Tiempo, en griego) fue una red de investigación europea para estudiar el diseño, implementación y aplicación de sistemas de gestión de bases de datos espacio-temporales. Su duración fue de aproximadamente 4 años, 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 L’Aquila (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 ontología, estructura y representación del espacio y del tiempo, (2) modelos y lenguajes para sistemas de gestión de bases de datos espaciales y temporales, (3) desarrollo de interfaces de usuario gráficas para información espacio-temporal, (4) procesamiento de consulta en bases de datos espacio-temporales, (5) estructuras de almacenamiento y técnicas de indexación para información 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 técnicas de indexación espacial y en el análisis 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 investigación. Posteriormente, he realizado estancias más cortas (2, con duración de un mes cada una) para evaluar los avances en la investigación en el entorno de esta tesis.

La creciente demanda de posibles consultas de muy diferente naturaleza en aplicaciones que organizan los datos utilizando métodos 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 rápidas ante consultas espaciales sobre estas estructuras de datos arbóreas, ya que éstos transforman los problemas en subproblemas de tamaño más pequeño conforme descienden en el recorrido de los árboles y reducen el espacio de búsqueda aplicando heurísticas de poda. Al mismo tiempo, hemos indagado en

Capítulo 1

4

técnicas que optimizan estas consultas en base al número de operaciones de E/S y al tiempo de respuesta, principalmente.

El join espacial y la consulta del vecino más próximo son, sin duda alguna, las consultas sobre métodos de accesos espaciales más 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 están más próximos a otro objeto espacial determinado. Ante preguntas del tipo: ¿cuáles son las 5 tiendas que están más cerca de un almacén cualquiera? o ¿cuáles son las ciudades con más de 500000 habitantes que están más próximas a algún río?, surge la consulta relacionada con los pares más cercanos basada en la relación de cercanía, y junto a ella la necesidad de diseñar 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 más próximo puesto que se utilizan heurísticas de poda basadas en distancias para reducir el espacio de búsqueda. Si partimos de la base de que los objetos espaciales que intervienen en la consulta o sus aproximaciones (MBRs) están indexados en uno de los métodos de acceso espacial más conocido y de eficiencia contrastada como es el R*-tree, entonces los algoritmos branch-and-bound son los más apropiados, ya que toman información sobre la optimalidad de soluciones parciales para evitar considerar soluciones que pueden no ser óptimas, y por tanto reducir el espacio de búsqueda notablemente.

1.3 Objetivos de la tesis

El conjunto de objetivos que han guiado el planteamiento de esta tesis, se resume básicamente en los siguientes puntos:

1. Revisión de las consultas espaciales más conocidas. Diseño e implementación de los algoritmos que llevan a cabo dichas consultas sobre métodos de acceso basados en MBRs (R*-tree).

2. Definición de la consulta del par más cercano y su extensión a los K pares más cercanos. Definición de funciones basadas en distancias entre pares de MBRs y heurísticas de poda para aplicarlas en algoritmos branch-and-bound [HoS78, Iba87, BrB97] (reducción del espacio de búsqueda) que den respuesta eficiente a dicha consulta siguiendo diferentes estrategias de búsqueda.

3. Implementación de algoritmos branch-and-bound no incrementales recursivos e iterativos para la consulta del par más cercano utilizando R*-tree como método de acceso espacial. Con el objetivo de minimizar el número de accesos a disco y tiempo de respuesta, se implementan técnicas de optimización utilizando las estructuras de datos más adecuadas.

Introducción

5

4. Adaptación de los algoritmos para la consulta del par más cercano a extensiones del mismo, como por ejemplo, los K pares más cercanos, la Auto-consulta y la Semi-consulta de los pares más cercanos, la consulta de los K pares más lejanos, etc.

5. Evaluación de los algoritmos para obtener los pares más cercanos y sus extensiones aplicadas a datos de naturaleza espacial (puntos), fundamentalmente respecto al número de accesos a disco y al tiempo de respuesta. Comparativa con la alternativa incremental [HjS98].

1.4 Contribuciones

Considerando el creciente interés demostrado por un importante número de investigadores hacia los algoritmos para el procesamiento de consultas sobre métodos de acceso espaciales, y muy especialmente en el join espacial, no resulta difícil observar que en este campo existe un trabajo futuro interesante. En este sentido, la tesis que presentamos representa una aportación adicional en dicha área, cuya particularidad más significativa es la de conjugar las características que nos ofrecen modernos métodos de acceso espacial con técnicas algorítmicas (branch-and-bound) para resolver consultas espaciales, en nuestro caso, la del par más cercano y sus extensiones [CMT+00a, CMT+00b].

Las contribuciones más destacables en el área del procesamiento de consultas espaciales sobre R-trees, resultado de la investigación 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 método de acceso. También, se presentan funciones basadas en distancias entre pares de MBRs y heurísticas de poda que, aplicadas en algoritmos branch-and-bound (recursivos e iterativos) para reducir el espacio de búsqueda sobre estructuras de datos arbóreas, hacen de la consulta del par más 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 más cercano, no sólo aplicables en el campo de las bases de datos espaciales [CRV01].

1.5 Descripción del contenido

Este apartado resume los contenidos que, capítulo a capítulo, el lector puede encontrar en el interior de esta memoria.

En el capítulo 2 se hace una revisión de los métodos de acceso multidimensionales más conocidos. Después se estudia el modelo de organización de índices basados en MBRs en un espacio de datos multidimensional, presentándose un conjunto de definiciones y propiedades de los mismos. Una vez descrito este modelo de organización, se hace una breve revisión de

Capítulo 1

6

los métodos de acceso multidimensionales basados en MBRs más conocidos, la familia de los métodos de indexación R-trees k-dimensionales. También, se definen formalmente las consultas espaciales más importantes. Finalmente, se realiza un estudio exhaustivo de los R*-trees, que es el método de indexación espacial más extendido y estudiado. Para ello, se presenta al R-tree como método de indexación base de los R*-trees, se describen todos los algoritmos que gestionan dinámicamente este método de acceso, y se diseñan todos los algoritmos para las consultas espaciales definidas previamente, utilizando este índice espacial.

El capítulo 3 se centra en la consulta base de esta tesis: la consulta del par más cercano y su extensión a los K pares más cercanos. En primer lugar se establecen los conceptos métricos necesarios para presentar la consulta en cuestión. Después se define dicha consulta y se proponen algunas aplicaciones de la misma, fundamentalmente en el campo de las bases de datos espaciales. A continuación, se establece la relación que existe entre la consulta del par más cercano, el join espacial y la consulta del vecino más próximo. Por último, se definen las métricas basadas en MBRs y teoremas que son la base para establecer heurísticas de poda para aplicarlas en algoritmos branch-and-bound (recursivos e iterativos) que den solución a esta consulta.

En el capítulo 4 se presentan una serie de algoritmos para dar respuesta a la consulta del par más 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 montículo mínimo para almacenar todos los posibles pares de MBRs organizados en base a la mínima distancia entre ellos como alternativa iterativa (estrategia de búsqueda de primero el mejor). Para mejorar aún más estos algoritmos branch-and-bound, se presentan técnicas de optimización pare reducir el número de accesos a disco y el tiempo de respuesta.

Las extensiones y casos de estudio presentados en este capítulo 5, pretenden demostrar el grado de operatividad que pueden proporcionar los algoritmos estudiados en el capítulo 4. Estas extensiones son las siguientes: (a) realizar la consulta del par más cercano sobre R*-trees con diferentes alturas, (2) poder llevar a cabo dicha consulta para el caso en que los objetos espaciales no están almacenados en los nodos hoja de los R*-trees, sino que en éstos están los MBRs que los envuelven junto con punteros a registros con la representación real de los objetos espaciales que están guardados en otro archivo externo, (3) obtener los K pares más cercanos, siendo esta extensión la más interesante y de gran aplicación, (4) encontrar todos o los K pares más cercanos que tienen una distancia en un rango dado a priori [Dist_Min, Dist_Max], (5) encontrar el par más lejano o los K pares más lejanos de dos conjuntos de objetos almacenados en R*-trees, y (6) realizar la Auto-consulta y la Semi-consulta de los pares más cercanos.

Los resultados experimentales desarrollados durante la preparación de esta tesis se reúnen en el capítulo 6. En él, llevamos a cabo un conjunto de experimentos para las diferentes versiones de los algoritmos branch-and-bound CPC y K-CPC, considerándose como parámetros principales de evaluación, el número de accesos a disco y el tiempo de respuesta. También se evalúan las dos técnicas 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 páginas junto con una política de reemplazo LRU (Least Recently Used), ya que reduce

Introducción

7

considerablemente la actividad de E/S de la consulta en cuestión. 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 capítulo 7, donde se resumen las conclusiones más destacables y se describen los trabajos a desarrollar en el futuro dentro de esta línea de investigación.

9

Capítulo 2

MÉTODOS DE ACCESO ESPACIALES BASADOS EN MBRs.

R*-TREE

2.1 Introducción

Existe un gran número de aplicaciones que requieren un acceso rápido según 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 métodos hashing. Para solucionar este problema, muchas estructuras que soportan acceso multidimensional han sido propuestas en los últimos años. De igual forma, dichas estructuras de acceso han sido desarrolladas para satisfacer los requerimientos (gestión de grandes volúmenes de datos de manera eficiente y rápida) en importantes campos de aplicación (GIS, CAD, multimedia, etc.) a nivel interno en sistemas de bases de datos actuales. De todas ellas, nos centraremos en las estructuras de datos arbóreas multidimensionales basadas en MBRs y balanceadas en altura que almacenan los datos en disco, los R-trees. Estos árboles se utilizan para la organización dinámica de un conjunto de objetos k-dimensionales representados por los mínimos rectángulos envolventes k-dimensionales.

En este capítulo vamos a presentar los métodos de acceso multidimensionales basados en MBRs. En primer lugar, haremos una revisión de los métodos de acceso multidimensionales más conocidos. Después estudiaremos el modelo de organización de índices basados en MBRs en un espacio de datos multidimensional, presentándose un conjunto de definiciones y propiedades de MBRs en dicho espacio. Una vez descrito este modelo de organización, se hará una revisión de los métodos de acceso arbóreos multidimensionales basados en MBRs

Capítulo 2

10

más conocidos, la familia de los métodos de indexación R-trees k-dimensionales. También, se definen las consultas espaciales más significativas. La última parte de este capítulo está dedicada al estudio de los R*-trees [BKS+90], que es el método de indexación espacial más extendido y estudiado. Para ello, introducimos a los R-trees [Gut84] como método de indexación base de los R*-trees, y todos los algoritmos necesarios para mantener este índice multidimensional. Además, presentamos los algoritmos para el procesamiento de las consultas espaciales más representativas definidas anteriormente, utilizando el R*-tree como método de acceso espacial.

2.2 Métodos de acceso multidimensionales. Una revisión

En los últimos años, aplicaciones cuyo uso ya es habitual, como los sistemas de información geográfica (GIS), diseño asistido por ordenador (CAD), aplicaciones multimedia, bases de datos de imágenes y, más recientemente, el tratamiento de almacenes de datos (Data Warehousing) o de datos de naturaleza temporal están exigiendo sistemas que sean capaces de gestionar de manera adecuada no sólo grandes volúmenes de datos sino también datos que incluyan una alta dimensionalidad.

Los métodos 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 múltiples atributos, sin necesidad de que haya una preferencia en el orden de los mismos, consultas en rango o consultas de proximidad. Además, estas estructuras deben adaptarse dinámicamente al crecimiento o disminución de la información de manera adecuada y ser capaces de gestionar grandes volúmenes de datos de alta dimensionalidad, obteniendo un rendimiento lo más cercano posible al del B+-tree [Com79].

En [GaG98, SPJ99] se resumen una serie de requerimientos que debería cumplir todo método de acceso, entre los que cabe destacar la simplicidad, independencia del orden de entrada y distribución 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 recuperación, y fácil integración en un sistema de base de datos tradicional con impacto mínimo en el resto del sistema. Evidentemente, muchos de los métodos propuestos cumplen sólo algunos de los requerimientos y es difícil que puedan ser implementados en sistemas reales, pero la mayoría han supuesto un paso más en las investigaciones proponiendo ideas y mecanismos que posteriormente han podido ser aplicados en la resolución de otros problemas.

Todos los métodos de acceso multidimensionales tienen en común 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 dimensión. Además, la estructura de datos se construye mediante divisiones recursivas de este espacio multidimensional, hasta obtener subespacios (mutuamente disjuntos o no) con un número de tuplas (u objetos) tal que permita poder almacenarlas en una página de datos.

Métodos de acceso espaciales basados en MBRs. El R*-tree

11

Los diferentes mecanismos para realizar estas divisiones del espacio y la implementación de los mismos dan lugar a distintos métodos de acceso multidimensionales. Dada la gran cantidad de estructuras de acceso multidimensionales existentes, las vamos a clasificar por grupos con características comunes y describiendo brevemente las más representativas de cada grupo.

La primera clasificación que realizamos presenta como resultado dos grandes grupos: (1) métodos de acceso que representan las divisiones del espacio mediante una estructura que debe mantenerse en memoria principal para obtener un mecanismo eficiente, y (2) métodos de acceso que paginan la estructura que representa la división del espacio, de tal manera que puede almacenarse en memoria secundaria.

2.2.1 Métodos de acceso multidimensionales basadas en memoria principal

Las primeras estructuras multidimensionales que surgieron están 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 indexación 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 más representativas es el k-d-tree [Ben75], que es un método de acceso que divide el espacio multidimensional de manera sucesiva en partes cada vez más pequeñas, 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 representación en un k-d-tree. Cada línea 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 según una determinada dimensión. La división se realiza fijando una dimensión en el nodo raíz (Y), siguiendo con otra dimensión (X) en los nodos del nivel siguiente, y así sucesivamente, cambiando de dimensión de manera cíclica.

(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 inserción: p1, p2, p3, p4, p5, p6).

Capítulo 2

12

Otra estructura de datos muy conocida que pertenece a esta categoría es el Quadtree [FiB74], donde cada nodo del árbol está asociado a una región cuadrada del espacio, por lo que la división recursiva de dicho espacio se hace en base a cuadrantes de igual tamaño. También debemos citar al BD-tree [OhS83], que presenta como novedad la identificación de regiones mediante secuencias de bits.

2.2.2 Métodos de acceso basados en almacenamiento secundario

Los métodos que se presentan en este apartado han sido diseñados para poder almacenarse en memoria secundaria, de forma que las estructuras de datos (archivos) que les dan soporte están paginadas. Inicialmente, distinguimos entre métodos de acceso a puntos (MAP), que se basan en considerar las tuplas como puntos en el espacio, y métodos de acceso espacial (MAE) que consideran no sólo puntos sino objetos en su extensión espacial. Los métodos de acceso a puntos, sin embargo, como explican sus diseñadores, pueden utilizarse también para direccionar objetos espaciales realizando una transformación, ya sea usando el centro del objeto, los vértices o alguna otra característica. Entre todos los métodos, independientemente de que sean MAP o MAE, se pueden a su vez observar aspectos en común y diferencias generales que permiten de algún modo clasificarlos, principalmente respecto a las características de las regiones a las que da lugar la división del espacio.

En la Tabla 2.1 se puede observar una clasificación general de los métodos de acceso basados en almacenamiento secundario más importantes.

Métodos de Acceso a Puntos (MAP) Métodos de Acceso Espaciales (MAE)

Hashing Jerárquicos Híbridos 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 Clasificación general de los métodos de acceso basados en almacenamiento secundario.


13

2.2.2.1 Métodos de acceso a puntos

Algunos de los métodos de acceso que se presentan están basados en la utilización de funciones de dispersión de registros (hashing) y otros están más próximos a estructuras arbóreas (jerárquicas). También hay otros métodos que toman ideas de ambos mecanismos (híbridos).

Métodos de acceso basados en hashing

Los métodos 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 método más conocido es el Grid File [NHS84], que representa la división del espacio mediante una rejilla de k dimensiones, cuyas celdas no siempre tienen el mismo tamaño. Esta estructura está formada por las páginas de datos (almacenadas en disco), el directorio (compuesto por las celdas k-dimensionales, permitiendo relacionar las celdas con las páginas de datos), y las escalas (mantienen información de las divisiones que se han realizado del espacio en cada dimensión). Mientras las páginas de datos y el directorio se mantienen en memoria secundaria, las escalas deberían estar en memoria principal para garantizar un rendimiento óptimo sobre consultas con varias claves de búsquedas.

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.

Métodos de acceso jerárquicos

La mayoría de estos métodos de acceso están basados en el k-d-tree [Ben75]. Su principal característica 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 región corresponde a una página de datos que está almacenada en disco como una hoja del árbol. Los nodos internos del árbol permiten guiar los procesos de búsqueda de arriba hacia abajo en la estructura.

Las operaciones de actualización 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 búsqueda aparecen sólo una vez, dividiendo el espacio unidimensional en varias partes según el orden del árbol. Tanto la inserción como el borrado requieren primero un proceso de búsqueda en el árbol hasta llegar al nivel más bajo. Si el elemento a insertar no cabe en la página correspondiente, se procederá a la división, lo que hace que haya que modificar la información en el nivel inmediatamente superior, que también puede desbordarse y así el proceso de división puede propagarse hacia arriba en el árbol.

Capítulo 2

14

5 8

1 3 6 7 9 12

Figura 2.2 Ejemplo de un B-tree (orden de inserción: 8, 5, 1, 7, 3, 12, 9, 8).

El mecanismo de división de las páginas de índice y los problemas que pueden producirse derivados del mismo es lo que distingue básicamente a los distintos métodos. En este sentido, hB-tree [LoB90] soluciona los problemas pendientes del K-D-B-tree [Rob81] y LSD-tree [HSW89], proponiendo un mecanismo de división más sofisticado. El Q-tree [Bar96], usando las ideas básicas del hB-tree, consigue una estructura más homogénea aunque no puede garantizar una ocupación mínima de las páginas en todas las situaciones. Una estructura ligeramente diferente es el BV-tree [Fre95], que no es realmente un método de acceso concreto, sino que representa un intento de generalizar las características del B-tree al caso multidimensional, proponiendo una serie de conceptos que pueden ser aplicados a otros métodos de acceso multidimensionales.

Métodos de acceso híbridos

Presentan características propias de métodos basados en hashing pero a la vez utilizan una estructura arbórea como base para la representación de la información. El más representativo es el Bang File [Fre87]. Este método realiza la división del espacio en intervalos regulares de la misma forma que un Grid File, pero representa el directorio mediante una estructura arbórea balanceada. En realidad, la filosofía de división y representación de regiones es muy similar a la del BD-tree [OhS83].

El Buddy-tree [SeK90] es un esquema basado en hashing dinámico con un directorio estructurado en forma de árbol. El árbol se construye por inserción consecutiva de elementos en él, dividiendo recursivamente el espacio en dos partes de igual tamaño con hiperplanos en la misma orientación.

2.2.2.2 Métodos de acceso espaciales

La mayoría de los métodos tradicionales de este tipo no fueron ideados para ser usados con más de 3 dimensiones y sólo recientemente han surgido estructuras pensadas para una alta dimensionalidad. Por ello, los métodos de acceso espaciales van a ser aquellos métodos de acceso diseñados principalmente para almacenar objetos geométricos.

La característica común que presentan estos métodos de acceso es que agrupan los objetos en regiones minimales, es decir, ajustadas a los objetos. Ahora bien, las características de


15

estas regiones difieren de unos métodos a otros, principalmente en lo que se refiere a su forma y a la relación que mantienen las que pertenecen al mismo nivel. Este último criterio nos permite clasificar los métodos en cuatro grupos: (1) aquellos que transforman los objetos en una representación diferente (mapeándolos en un punto de dimensión mayor o transformándolos en un conjunto de intervalos unidimensionales según 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 múltiples capas, que en realidad es una extensión del primero.

La estructura pionera es el R-tree [Gut84] que ha servido de base a otros muchos métodos que surgieron al tratar de mejorar algunos aspectos del mismo. Ésta es una estructura arbórea multidimensional balanceada en altura que representa una jerarquía de regiones rectangulares minimales (MBRs). Es decir, los R-trees son estructuras de datos arbóreas 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 página de datos. En los nodos hoja están almacenados un identificador para cada objeto y el MBR que lo contiene, y los nodos internos representan una sucesión 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 unión no necesariamente cubre el universo completo. El árbol está balanceado en altura y se garantiza una ocupación mínima de los nodos. En años 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 métodos que manejan regiones solapadas, R-tree, R*-tree [BKS+90], P-tree [Jag90], etc., tienen el problema de que una búsqueda exacta puede tener que seguir varios caminos, aunque en algunas estructuras como el R*-tree, el solape ha disminuido mucho pero el proceso de inserción resulta más complejo y costoso. Los métodos que manejan regiones disjuntas, R+-tree [SRF87] y Cell-tree [Gün89], 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 inserción. En general, todos los métodos de acceso de este tipo, excepto el Cell-tree, manejan regiones minimales por lo que nuevas inserciones de objetos pueden producir actualizaciones en los límites de las regiones, aún cuando no haya desbordamiento de páginas.

En los últimos años han surgido métodos 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. Además, algunos presentan como novedad la forma de las regiones, que ya no es rectangular: el SS-tree maneja regiones esféricas, el SR-tree utiliza esferas y MBRs, y el Pyramid-tree gestiona pirámides. 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 representación exacta de los MBRs; el segundo nivel lo denominan páginas de datos comprimidas, que contienen puntos de forma comprimida; y el tercer nivel guarda la representación exacta de los datos. El A-tree (Approximation tree) es un índice arbóreo para la búsqueda por cercanía en espacios de datos multidimensionales y que utiliza para la representación de los MBRs y de los objetos, una aproximación relativa de sus MBRs ancestros denominada VBR (Virtual Bounding Rectangle).

Capítulo 2

16

2.3 Modelo de organización de índices basados en MBRs en el espacio de datos k-dimensional

Para definir el modelo de organización de índices basados en MBRs en el espacio de datos k-dimensional debemos introducir una serie de conceptos básicos tomados fundamentalmente de [Pol96, Bec92, ElN97], aunque también se han utilizado para ello [ACP+99, DeP99, GUW99, MTT99, One94, Ram97, RSV01, SKS98, ZCF+97].

Definición. Espacio n-dimensional de datos. Se define el espacio n-dimensional de datos (espacio multidimensional) D(n) como:

( ){ }iiniinn DvvDDDD ∈=×××= ≤≤ : ... 121

)(

donde cada dominio Di está formado por un conjunto de valores, sobre los que está definida una relación de orden ≤i, que salvo indicación explícita, se denotará como ≤ para cualquier 1≤i≤n. Además, dichos dominios no tienen que ser necesariamente distintos.

Definición. Tupla n-dimensional. Se define una tupla n-dimensional t en D(n), como un conjunto finito de n valores de la forma. t = (v1, v2, ..., vn) = (vi)1 ≤ i ≤ n ∈ D(n) : donde v i ∈ Di

Según [ElN97], las bases de datos desde un punto de vista físico están organizadas en archivos de registros los cuales se almacenan físicamente en la computadora utilizando medios de almacenamiento no volátil, como puede ser un disco duro. Las aplicaciones de base de datos sólo requieren una pequeña parte de la información 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 información 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) están almacenadas en un archivo n-dimensional de datos, F. Los registros de F están distribuidos según un índice multidimensional, I, no denso (tiene una entrada por cada página de datos del archivo de datos, no una por cada registro) que está asociado a dicho archivo n-dimensional de datos.

Definición. Archivo n-dimensional de datos. Un archivo n-dimensional de datos es un par F = ({A1, A2, ..., An}, {(vi)1 ≤ i ≤ n ∈ D(n)}), donde {(vi)1 ≤ i ≤ n ∈ D(n)} son tuplas n-dimensionales y {A1, A2, ..., An} 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 colección de tuplas n-dimensionales, caracterizadas por un conjunto de n atributos.


17

Definición. Conjunto de atributos clave en un archivo n-dimensional de datos. Dado un archivo n-dimensional de datos F = ({A1, A2, ..., An}, {(vi)1 ≤ i ≤ n ∈ D(n)}), se dice que un subconjunto de atributos {A1, A2, ..., Ak} (k ≤ n) es clave de F, si dadas dos tuplas t = (v1, v2, ..., vn) y t’ = (v1’, v2’, ..., vn’) ∈ F y t ≠ t’, entonces existe un i (1 ≤ i ≤ k) tal que v i ≠ vi’.

Es decir, un subconjunto de atributos {A1, A2, ..., Ak} 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 {A1, A2, ..., An} que caracteriza a un archivo n-dimensional de datos se puede dividir en dos subconjuntos C y C’, donde C = {A1, A2, ..., Ak} es el conjunto de atributos que son clave para la organización del archivo n-dimensional, y C’ contiene los atributos que no son clave para la organización del archivo. Es decir, una tupla n-dimensional de un archivo n-dimensional de datos está caracterizada por los atributos {A1, A2, ..., An}, de los cuales C son atributos clave y los restantes C’ son atributos no clave (n = C + C’).

Basándonos en el modelo de representación de información multidimensional [Pol96] podemos definir una estructura de datos que nos permita realizar una organización de dicho espacio sobre k atributos bajo determinadas condiciones, dando lugar a lo que denominaremos índice arbóreo k-dimensional.

Definición. Índice arbóreo k-dimensional balanceado en altura. Un índice arbóreo 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 <Ki, Pi>, siendo Ki un conjunto de tuplas k-dimensionales y Pi un puntero (número), que denominaremos entradas del nodo.

Dicho índice arbóreo 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 número finito de entradas de la forma <Ki, Pi>. Ki es una tupla k-dimensional y Pi, es un puntero (posición absoluta de un registro en un archivo) que puede apuntar a un registro del índice arbóreo k-dimensional o a un registro del archivo k-dimensional de datos siguiendo alguna propiedad específica. El desarrollo de estos procedimientos está enfocado a la construcción del índice mediante la organización de los datos multidimensionales en el espacio k-dimensional, obteniendo subconjuntos en subespacios (disjuntos o no) con un número de nodos que puedan ser almacenados en el archivo. Los diferentes mecanismos para realizar estas organizaciones del espacio y la implementación de los mismos dan lugar a distintos tipos de índices arbóreos k-dimensionales balanceados en altura.

Un índice arbóreo k-dimensional, como estructura de datos arbórea, estará compuesta por nodos (registros). Cada nodo del índice, a excepción de un nodo especial denominado raíz, tiene un nodo padre y varios (cero o más) 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 subárbol comenzando en un nodo consiste en ese nodo y en todos sus descendientes.

Capítulo 2

18

Definición. Nodos hoja y nodos internos de un índice arbóreo k-dimensional. Un nodo hoja, de un índice arbóreo k-dimensional es cualquier nodo tal que: Los punteros (Pi) que son nulos, indican que no tiene nodos hijos del árbol. Y los punteros (Pi) que no son nulos, son punteros al archivo k-dimensional de datos. Un nodo interno, de un índice arbóreo k-dimensional es todo nodo del índice que no sea un nodo hoja.

Definición. Orden y grado de un nodo en un índice arbóreo k-dimensional. Llamaremos orden de un nodo N en un índice arbóreo k-dimensional y se denotará por (m, M), al número mínimo (m) y máximo (M), respectivamente, de pares de la forma <Ki, Pi> que pueden almacenarse en dicho nodo. Llamaremos grado de un nodo N en un índice arbóreo k-dimensional y se representa por grado(N), al número 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 <Ki, Pi>) mínimo es m, el máximo es M, y está ubicado en el nivel l (l > 0). Entonces ml es una cota inferior y Ml es una cota superior para el grado de N (ml≤grado(N)≤Ml).

De las definiciones anteriores, podemos deducir que el número de nodos, Num_Nodos, de un índice arbóreo k-dimensional balanceado en altura de orden (m, M) y de altura h (nivel del nodo raíz más uno) viene dado por la siguiente expresión.

∑∑−

=

−

=

≤≤1

0

1

0

_h

l

lh

l

l MNodosNumm

Una vez recordado brevemente el modelo de representación de información multidimensional y definido de forma general un índice arbóreo k-dimensional balanceado en altura, vamos a destacar los aspectos más importantes del modelo de representación de MBRs k-dimensionales sobre el espacio multidimensional de datos junto con la definición de índice arbóreo k-dimensional balanceado en altura y basado en MBRs k-dimensionales.

Definición. Segmento o intervalo en el espacio de datos n-dimensional. Dado un espacio n-dimensional D(n), y una relación de orden ≤i definida sobre cada uno de sus dominios Di. Definimos un intervalo o segmento en la dimensión i de D(n) como:

[ ] { }iiiiiiii uvlDvulI ≤≤∈== : ,

Definición. n-rectángulo cerrado y limitado por un conjunto de intervalos en el espacio n-dimensional. Definimos un rectángulo n-dimensional o n-rectángulo, n_R, delimitado por un conjunto de intervalos I = {[l1, u1], [l2, u2], ..., [ln, un]} como una región de D(n) en la que todas sus coordenadas están acotadas por un intervalo [li, ui] sobre la dimensión i. Es decir, n_R es de la forma:

( ) ( ){ }iiiiin

nii DvuvlDvRn ∈≤≤∈= ≤≤ , : _ 1

Definición. n-rectángulo cerrado y limitado por dos puntos (P1 y P2) en el espacio n-dimensional. Sean los puntos n-dimensionales P1 = (pi

1)1 ≤ i ≤ n y P2 = (pi2)1 ≤ i ≤ n ∈ D(n), tal que pi

1 ≤ pi2,

llamaremos n-rectángulo cerrado y limitado por los puntos P1 y P2, y cuyas caras son


19

paralelas a los ejes de coordenadas en cada dimensión, al conjunto de tuplas caracterizado por la siguiente expresión:

( ) ( ){ }iiiiin

niiPPDvpvpDvRn ∈∀≤≤∈= ≤≤ , : _ 21

1, 21

En la Figura 2.3 podemos ver n-rectángulos 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_RA,B con A = (3, 6, 0, 5) y B = (9, 12, 3, 7); representa el conjunto de tuplas de la forma t = (v1, v2, v3, v4) tales que, 3 ≤ v1 ≤ 9, 6 ≤ v2 ≤ 12, 0 ≤ v3 ≤ 3 y 5 ≤ v4 ≤ 7.

(a) (b) (c)

Figura 2.3 Ejemplo en una, dos y tres dimensiones de un n-rectángulo definido por dos puntos.

Definición. MBR (Minimum Bounding Rectangle) n-dimensional. Mínimo n-rectángulo que envuelve a un conjunto T de tuplas n-dimensionales. Dado un conjunto finito de tuplas n-dimensionales T = {t1, t2, ..., tm} : ti ∈ D(n). Éste estará contenido en un n-rectángulo cerrado definido por los puntos PT

min y PTmax, y con sus caras

paralelas a los ejes de coordenadas en cada dimensión, que denominaremos cubrimiento mínimo, envolvente mínimo, n-rectángulo minimal de T, o de manera abreviada MBR n-dimensional.

( ) ( ){ }iiiiin

niiPPDvpvpDvRn

TT∈≤≤∈= ≤≤ , : _ maxmin

1, maxmin tal que,

( ) ( ) ( )

=∈= ∏≤≤≤≤

ij

mji

nniiT tpDpP

1

min1

minmin min :

( ) ( ) ( )

=∈= ∏≤≤≤≤

ij

mji

nniiT tpDpP

1

max1

maxmax max :

A PTmin y PT

max se les denomina cubrimiento inferior y superior de T, respectivamente. Y Πi representa la proyección en la i-ésima dimensión.

Debemos indicar que las caras de un MBR n-dimensional son MBRs de una dimensión 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_RPT

min,PTmax con PT

min = (2, 0, 2) y PTmax = (5, 10, 25). Además, este MBR 3-

dimensional consta de 6 caras que son MBRs 2-dimensionales.

Basándonos en el modelo de representación de MBR n-dimensionales sobre el espacio multidimensional de datos, y extendiendo la definición de índice arbóreo k-dimensional

Capítulo 2

20

balanceado en altura, vamos a introducir el concepto de índice arbóreo 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.

Definición. R-tree k-dimensional. Definimos un R-tree k-dimensional como un índice arbóreo k-dimensional balanceado en altura que verifica las siguientes propiedades:

• Cada nodo hoja contiene entradas de la forma <Ki, Pi>, tal que Ki es el MBR k-dimensional que cubre un conjunto de tuplas k-dimensionales T, almacenado en un archivo k-dimensional de datos. Y Pi es un puntero a algunas de esas tuplas k-dimensionales que forman el conjunto T. Pi puede ser nulo, entonces las tuplas almacenadas en Ki representan información de utilidad para el usuario.

• Cada nodo interno contiene entradas de la forma <Ki, Pi>, donde Pi es un puntero a un nodo hijo y Ki 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 raíz, contiene entre m y M entradas, donde 2 ≤ m ≤ M/2. M es el máximo número de entradas que puede tener cada nodo (capacidad máxima del nodo). Por otro lado, m es un parámetro que especifica el mínimo número de entradas en un nodo. El R-tree k-dimensional garantiza que la utilización del almacenamiento es al menos m/M [Gut84], y que la altura del árbol crece de forma logarítmica en función del número de objetos caracterizados por tuplas k-dimensionales a indexar. Además, cada nodo del índice se corresponde con una página 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 máximo logm (N) si se indexan N objetos caracterizados por tuplas k-dimensionales y m es el número mínimo de entradas que puede haber en un nodo de dicho índice.

• El nodo raíz contiene al menos dos entradas, si éste no es una hoja.

Debemos destacar también que el R-tree k-dimensional es un método de indexación multidimensional completamente dinámico, en el que inserciones y borrados pueden llevarse a cabo junto con consultas sin necesidad de realizar una reorganización de la información k-dimensional a nivel global.

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

Los R-trees [Gut84] son estructuras de datos arbóreas multidimensionales basadas en MBRs, y balanceadas en altura. Éstas se utilizan para la organización dinámica de un conjunto de objetos k-dimensionales representados por sus MBRs k-dimensionales.

Como hemos mencionado anteriormente, los métodos de acceso diseñados para almacenar objetos geométricos caracterizados por su mínima envolvente se les denomina métodos de


21

acceso espaciales (MAE). Un punto es un caso particular de objeto geométrico y puede ser gestionado por estos índices, aunque métodos de acceso a puntos (MAP) también pueden utilizarse para almacenar objetos geométricos aplicando técnicas concretas [Bec92]. La mayoría de los MAE han sido diseñados exclusivamente para la gestión de objetos espaciales (puntos, líneas, regiones, polígonos, etc.). Por ello, es conveniente destacar las propiedades básicas de los datos espaciales según [GaG98]:

1. Los datos espaciales tienen una estructura compleja. Un objeto espacial puede estar compuesto por un único punto o por varios miles de polígonos, distribuidos arbitrariamente en el espacio.

2. Los datos espaciales son a menudo dinámicos. Operaciones de actualización, inserción y borrado se llevan a cabo sobre los MAE utilizados en este contexto para soportar un comportamiento dinámico sin deteriorar el tiempo de procesamiento.

3. No hay definida un álgebra estándar sobre datos espaciales, aunque se han hecho varias propuestas entre las que podemos citar [Güt89, ScV89, GüS93]. 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 aplicación, aunque algunos operadores son más comunes que otros, como por ejemplo el operador de solape.

4. Muchos operadores espaciales no son cerrados, ya que cuando actúan 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 operación. Por ejemplo, el solape entre dos polígonos (una o más veces de forma consecutiva) puede devolver un número de puntos aislados, aristas separadas, o polígonos disjuntos.

5. Aunque el coste computacional varía entre operadores espaciales, dichos operadores son más costosos de llevar a cabo que los operadores relacionales estándares.

Según [Güt94], 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 indexación espacial y algoritmos eficientes para el procesamiento de consultas espaciales. De lo cual se deduce la gran importancia que tienen los métodos de acceso espaciales (MAE) como mecanismo de indexación 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 información espacial de utilidad para el usuario.

Cuando tenemos un objeto espacial O en el espacio bidimensional, el rectángulo más pequeño 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 rectángulo puede representarse por dos puntos, uno de ellos en la esquina inferior izquierda que está definido por (xmin, ymin), y el otro

Capítulo 2

22

es el punto situado en la esquina superior derecha y definido por (xmax, ymax). Entonces xmin es la coordenada X más pequeña posible de todos los puntos de O e ymin es de igual forma la coordenada Y más pequeña posible de todos los puntos de O. De forma similar se define xmax como la coordenada X más grande posible de todos los puntos de O e ymax la coordenada Y más grande posible de todos los puntos de O. A este rectángulo se le denomina mínimo rectángulo que envuelve o cubre al objeto espacial O, o de manera abreviada MBR. La siguiente figura ilustra este concepto.

(xmin, ymin)

(xmax, ymax)

(xmin, ymin)

(xmax, ymax )

(a) X (c) X X

Y Y Y

(0, 0) (0, 0) (0, 0) (b)

*

Figura 2.4 MBRs de uno o más 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(O1) ∩ MBR(O2) ≠ ∅, siendo O1 ∩ O2 = ∅. En la Figura 2.4.c aparece la extensión de MBR para cubrir a varios objetos. Por último, el concepto de MBR descrito para dos dimensiones (k = 2), puede extenderse fácilmente para cualquier dimensión k ≥ 2.

La versión original del R-tree [Gut84] ha inspirado a muchos investigadores para realizar mejoras sobre el mismo, con el objetivo de obtener métodos de acceso espaciales basados en el R-tree y mejorar su rendimiento. Una técnica de empaquetado (packing) se propone en [RoL85] para minimizar el solape entre diferentes nodos en el R-tree para datos estáticos. La idea para llevar a cabo esta técnica es ordenar los MBRs de forma ascendente según el valor de su coordenada xmin, examinar la lista de MBRs ordenada y llenar cada nodo hasta su capacidad máxima aplicando criterios del vecino más próximo. En [KaF93] se estudia una técnica que mejora el método 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. Más recientemente, en [LEL97] se muestra un método 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 perímetro de los MBRs, junto con técnicas de buffering para minimizar el número de accesos a disco, comparándolo con las dos técnicas anteriores.

Otro método de indexación 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 raíz. Todas estas restricciones nos pueden conducir a un incremento en la altura del árbol que depende del


23

grado de solape que exista en el conjunto original de objetos a indexar. No obstante, el tiempo necesario para la recuperación de información es más rápido debido a que si se toma un camino, éste lleva con toda seguridad al objeto requerido sin necesidad de retroceder en el proceso de búsqueda. Debido a que el R+-tree se puede considerar como una extensión del K-D-B-Tree, éste no garantiza siempre un rendimiento óptimo en el llenado de nodos del árbol. Pueden existir páginas que no se llenen a la mitad de su capacidad sin la utilización de complicados algoritmos de inserción 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 elección de líneas de división junto con una cuidadosa agrupación inicial de los MBRs a nivel de hojas. Esta última mejora puede llevarse a cabo utilizando heurísticas 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 método de indexación multidimensional derivado del R-tree y difiere de este último en la forma de dividir y combinar nodos en el proceso de inserción de objetos. La principal idea es el concepto de reinserción forzada, donde se trata de aplazar la división de un nodo cuando éste se desborda (overflow). En concreto, cuando un nodo se desborda (supera su capacidad máxima, M), algunas de sus entradas son cuidadosamente escogidas siguiendo determinados criterios, extraídas 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 inserción de objetos espaciales con técnicas más sofisticadas que intentan minimizar el solape entre MBRs en un mismo nivel del árbol y su perímetro total. Cuando un nodo N de un R-tree se desborda, en lugar de dividir inmediatamente N, el algoritmo de inserción del R*-tree primero trata de ver si alguna de las entradas de N podría ser ubicada mejor en otro nodo. Esto se lleva a cabo mediante un proceso de reinserción de una fracción fija de las entradas de N. Este proceso incrementa el tiempo en la construcción 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 división de nodos cuya capacidad ha sido superada fue también incorporada en la implementación de Hilbert R-tree [KaF94]. En esta nueva versión 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 quién es el hermano de un MBR dado, y posteriormente aplicando la política de división de 2-a-3 (o generalizando, de s-a-(s+1)) de los B*-tree. Otra característica del Hilbert R-tree es que en los nodos internos también se almacena el valor Hilbert más grande de los MBRs del subárbol del que él es raíz (además del MBR y el puntero al subárbol correspondiente), facilitando considerablemente la inserción de nuevos objetos. Para el caso del Hilbert R-tree, al igual que ocurre con el R*-tree, genera una mejor distribución del espacio que el R-tree convencional, y además tiene un tiempo de respuesta mejor, debido a que el árbol es más compacto y reducido.

En [BKK96] se ha propuesto una modificación del R*-tree, denominada X-tree, que por los resultados presentados en dicho artículo es un método de acceso muy apropiado para la indexación de datos multidimensionales. El X-tree reduce el solape entre MBRs de nodos internos utilizando un nuevo concepto, el supernodo. Este método de acceso aplaza la división

Capítulo 2

24

de nodos introduciendo supernodos, es decir, nodos con una capacidad mayor que la del tamaño máximo de un bloque normal. Además, para encontrar la división más apropiada, el X-tree también mantiene la historia de las divisiones anteriores.

En la Tabla 2.2 podemos observar los métodos de accesos espaciales más representativos de la familia del R-tree k-dimensional.

Nombre Antecedente Región Reinserción Características

R-tree [Gut84] B-tree MBRs Solapados No Varios criterios para la división. Búsquedas por varios caminos.

Hilbert R-tree [KaF94]

R-tree MBRs Solapados Sí El criterio de división 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 reinserción antes de realizar la división.

R+-tree [SRF87]

R-tree MBRs Disjuntos No Redundancia de objetos. Divis ión en cascada. No garantiza páginas llenas.

X-tree [BKK96]

R-tree MBRs Solapados No La estructura no es homogénea, puesto que puede haber nodos de gran tamaño (supernodos). El criterio de división depende del solape y de la historia de la división en una determinada dimensión.

TV-tree [LJF94]

R-tree Esferas solapadas con dimensión reducida

Sí El criterio de inserción está condicionado al número de regiones solapadas, al número de dimensiones inactivas y al radio de la región.

SS-tree [WhJ96]

R-tree Esferas Solapadas Sí La estructura es compleja y el criterio de inserción depende de la proximidad al centro de la esfera. Las búsquedas 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 Clasificación de los métodos de acceso más representativos de la familia del R-tree k-dimensional.

Otras variantes del R-tree consideran formas más generales para la mínima envolvente de objetos espaciales, tratando de minimizar los espacios muertos que se pueden producir en un MBR. En [Gün89] se propone el Cell tree, cuya principal característica 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 mínimas envolventes son polígonos con inclinación de las caras de 0, 45, 90 y 135 grados. Mínimas formas envolventes que son cóncavas o incluso tienen huecos han sido sugeridas en [LoS90] para definir el hB-tree.

2.5 Consultas espaciales


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. Después, se aplica dicho lenguaje para formular consultas estándar (consulta exacta, consulta en rango, equijoin y semijoin) y geométricas (consulta para la localización de un punto, consulta de ventana, consulta de solape, join espacial, etc.). Nosotros sólo vamos a tratar las consultas que se aplican sobre métodos de acceso espaciales, denominadas consultas espaciales.

Según [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 algún tipo de dato espacial (punto, línea, región, polígono, etc.). Este atributo espacial describe la geometría del objeto O, y lo denotamos como O.geo. La geometría de objetos espaciales es muy compleja, ya que se formula en base a parámetros como por ejemplo: número de vértices que forman dichos objetos, la distribución de los mismos en el espacio, sus formas, etc.

Los métodos de acceso espaciales organizan los objetos espaciales en base a su clave geométrica. El MBR es la clave geométrica más popular [BKS+94]. Utilizar el MBR como aproximación del objeto espacial original reduce la complejidad del objeto a los dos puntos que determinan el rectángulo mínimo (caras paralelas a los ejes coordenados) que cubre al objeto y conserva las características más importantes del objeto espacial que son su posición y su extensión.

Los objetos espaciales se gestionan mediante operaciones espaciales. Una operación espacial la podemos definir como una función con argumentos espaciales, es decir, dicha función toma objetos espaciales como operandos y devuelve objetos espaciales o valores escalares como resultado. En [Sch97] se clasifican los operadores espaciales en las siguientes categorías:

• Predicados espaciales que devuelven valores booleanos.

• Operaciones espaciales que devuelven valores numéricos.

• 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 numéricos.

La categoría de las operaciones espaciales que devuelven valores numéricos contiene operaciones que calculan una propiedad métrica de un objeto espacial y devuelve un valor escalar:

• La operación área devuelve el área de un objeto región, mientras que la operación perímetro devuelve el valor del perímetro de una región espacial.

Capítulo 2

26

• La operación longitud calcula la longitud total de un objeto línea.

• El diámetro de un objeto espacial se define como la distancia más larga entre cualquier par de sus componentes.

• En esta categoría también tenemos a las operaciones relacionadas con la distancia. La operación distancia (d) calcula la distancia entre dos puntos, que es siempre un valor mayor o igual que cero, d : (P1, P2) → ℜ+. La distancia entre dos objetos viene determinada por las operaciones mindist y maxdist. Las operaciones mindist y maxdist calculan la distancia mínima y máxima entre dos objetos espaciales.

• Las operaciones de dirección calculan los ángulos entre dos objetos espaciales como un número real en el rango desde 0º0’0’’ hasta 359º59’59’’.

• Otra operación que devuelve valores numéricos es la que determina el número de componentes (cardinalidad) de un conjunto de objetos espaciales formados por puntos, líneas o regiones.

Las operaciones espaciales que devuelven valores booleanos están asociadas a predicados espaciales que pasamos a definir a continuación.

Definición. Predicado espacial y Fórmula atómica espacial. Un predicado espacial, Φ(·), es la formalización de una propiedad espacial. Un predicado espacial será unario, binario o n-ario en función del número de objetos espaciales (argumentos) que compare. Φ(·), aplicado a objetos espaciales definidos sobre alguna colección no vacía de atributos {A1, A2, ..., Ak} en el espacio Euclídeo k-dimensional, E(k) (espacio multidimensional de datos dotado de la distancia Euclídea), es una función booleana aplicada a dichos objetos sin ningún 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 fórmulas atómicas espaciales.

Definición. Sentencia espacial. Una sentencia espacial, Θ(·), es un conjunto de fórmulas atómicas espaciales con conectores lógicos (∧ (and), ∨ (or) y ¬ (not)).

Por ejemplo: Θ(·) : Φ1(·) ∧ Φ2(·) ∧ ... ∧ Φn(·), Θ(·) : Φ1(·) ∨ Φ2(·)∨ ... ∨ Φn(·), Θ(·) : Φ1(·) ∧ ¬Φ2(·)∨ Φ3(·) ∧ ... ∨ Φn(·)

La evaluación 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 están 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 asignación de un objeto espacial (constante) a esa variable espacial. También puede ocurrir que la evaluación de una sentencia espacial no


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 añadirle algún símbolo 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 (fórmula espacial atómica) como para las sentencias espaciales.

Una consulta espacial en la que intervienen objetos espaciales, donde hay un conjunto de atributos o extensión espacial (O.geo) en cada uno de ellos, está descrita por:

• El tipo de dato espacial (punto, línea, región, etc.) que representa dicho conjunto de atributos.

• El predicado espacial que deben satisfacer los objetos resultantes.

Definición. Consulta espacial. Una consulta espacial aplicada a un objeto espacial O’ definido en el espacio Euclídeo k-dimensional, E(k) (espacio multidimensional de datos dotado de la distancia Euclídea), 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 las relaciones topológicas, que caracterizan propiedades como continuidad, adyacencia, solape, inclusión, conectividad, etc. Otras relaciones espaciales conocidas son las métricas (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 continuación, al igual que en [GaG98], vamos a realizar la definición formal de los tipos de consultas espaciales más comunes.

Tipo de Consulta Espacial 1. Consulta Exacta. CE. Dado un objeto O’ con extensión espacial O’.geo ⊆ E(k), encontrar todos los objetos O con la misma extensión espacial que O’.

CE(O’) = {O : O’.geo = O.geo}

Tipo de Consulta Espacial 2. Consulta para la Localización 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}

Capítulo 2

28

Tipo de Consulta Espacial 3. Consulta en Rango o Consulta de Ventana. CR. Dado un k-rectángulo 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 común con R.

CR(R) = {O : R ∩ O.geo ≠ ∅}

Debemos destacar que las caras del k-rectángulo R son paralelas a los ejes de coordenadas. Un tipo más general de consulta sería aquella que permite la búsqueda de regiones que tienen diferentes orientaciones y formas. Por ejemplo, dado un punto y una distancia (radio) tendríamos una consulta en rango sobre una hiperesfera definida en el espacio Euclídeo k-dimensional, E(k).

Tipo de Consulta Espacial 4. Consulta de Solape. CS. Dado un objeto O’ con extensión espacial O’.geo ⊆ E(k), encontrar todos los objetos O que tienen al menos un punto en común con O’.

CS(O’) = {O : O’.geo ∩ O.geo ≠ ∅}

Tipo de Consulta Espacial 5. Consulta de Cubrimiento. CCu. Dado un objeto O’ con extensión 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 Inclusión. CIn. Dado un objeto O’ con extensión espacial O’.geo ⊆ E(k), encontrar todos los objetos O cubiertos por O’ (todos los objetos O que están incluidos en O’).

CIn(O’) = {O : O’.geo ∩ O.geo = O.geo}

Las consultas de cubrimiento (CCu) e inclusión (CIn) son simétricas entre ellas. Estos dos tipos de consultas espaciales son casos particulares y más restrictivos de la consulta de solape (CS), ya que especifica que el resultado de la operación será uno de los dos objetos espaciales de entrada.

Tipo de Consulta Espacial 7. Consulta de Adyacencia. CA. Dado un objeto O’ con extensión espacial O’.geo ⊆ E(k), encontrar todos los objetos O adyacentes a O’.

CA(O’) = {O : O’.geo ∩ O.geo ≠ ∅ ∧ O’.geoo ∩ O.geoo = ∅}

Donde O’.geoo y O.geoo 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 más Próximo. CVP. Dado un objeto O’ con extensión espacial O’.geo ⊆ E(k), encontrar el objeto O con extensión espacial O.geo ⊆ E(k), que tiene una distancia mínima desde O’.

CVP(O’) = {O : ∀O’’ ≠ O, d(O’.geo, O.geo) ≤ d(O’.geo, O’’.geo)}


29

Debemos destacar que la distancia Euclídea, d, entre objetos espaciales se define normalmente como la distancia entre sus puntos más próximos. Otra función de distancia muy conocida, aparte de la distancia Euclídea, 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 evaluación del predicado espacial Θ(O.geo, O’.geo) es cierta.

JE(P, Q, Θ) = {(O, O’) ⊆ P×Q : Θ(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, Gün93, LoR94, Ore86, PTS95, Rot91, ShA97]. Estas posibilidades para Θ incluyen entre otros: solapa, cubre_a, cubierto_por, noroeste, adyacente, encuentra, etc. Si estudiamos las características topológicas 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, arbórea, 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 consistía 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 reducción del rendimiento ante tales operaciones. Además, en [BKS+90] se confirma la observación hecha en [RoL85], de que un factor clave para el rendimiento de un R-tree respecto al procesamiento de consultas es la organización de los MBRs en dicho método de acceso durante el proceso de inserción.

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

El R-tree [Gut84] es una estructura de datos arbórea multidimensional basada en MBRs, balanceada en altura y almacenada en disco, derivada del B+-tree [Com79]. Este método de acceso es apropiado tanto para la indexación 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 están 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

Capítulo 2

30

forma general, podemos decir que esta estructura arbórea multidimensional organiza una colección de objetos representados por sus MBRs.

A menudo, los nodos se corresponden con páginas de disco, y por tanto los parámetros para definir el árbol se escogen con el objetivo de optimizar el procesamiento de una consulta sobre él. Nótese que en un R-tree los MBRs que están en nodos internos pueden solaparse, es decir, MBRs en diferentes entradas de un nodo pueden tener un área de solape común. É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 la 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 páginas del archivo de datos. Además, en dicha figura podemos observar la principal característica del R-tree: MBRs definidos en el mismo nivel pueden solaparse (A, B y C). Debemos notar también 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 inserción de un MBR en un R-tree es muy similar al utilizado para los B+-trees. Los nuevos MBRs se añaden en los nodos hoja. Para determinar el nodo hoja apropiado para la inserción debemos recorrer el R-tree empezando desde la raíz y en cada paso escoger el subárbol cuyo MBR correspondiente tendría que expandirse lo mínimo 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 comprobación para ver si el MBR a insertar puede provocar un desbordamiento en el nodo (exceda su capacidad máxima, 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 raíz). Si ocurre desbordamiento, entonces el nodo debe dividirse, y las M + 1 entradas del nodo deben distribuirse en dos nodos. Dicha división se propaga en el árbol hacia la raíz, si es necesario, y se realizan los ajustes pertinentes de los MBRs.

Existen muchas formas de dividir un nodo. Una posible alternativa sería distribuir las entradas del nodo que ha excedido su capacidad máxima (tendría M + 1 entradas) entre dos nodos, tal que la probabilidad con la que ambos nodos se visitarán en operaciones de búsqueda posteriores se reduzca al máximo. Esto se consigue minimizando el área total de los


31

MBRs que cubren ambos nodos (factor de cobertura). Otra alternativa es reducir la probabilidad de que ambos nodos se examinen en operaciones de búsqueda posteriores. Esto se consigue minimizando el área común 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 situación, donde la línea discontinua representa el MBR asociado a las nuevas particiones de MBRs que resultan de tratar el nodo desbordado según las alternativas anteriores. Consideremos los cuatro MBRs que se muestran en la Figura 2.6.a y supongamos que están en un nodo que ha excedido su capacidad máxima (M = 3) entonces se tendría que realizar la división. La primera alternativa (minimizar el factor de la cobertura) se cumple para la división en la Figura 2.6.b puesto que se minimiza el área que cubre a los MBRs que estarían distribuidos en dos nodos, y la segunda (minimizar el factor de solape) en la Figura 2.6.c, ya que se minimiza el área común a los MBRs que cubren a los dos nuevos nodos generados por la división.

(a) (b) (c)

Figura 2.6 Alternativas para la división de un nodo que ha excedido su capacidad máxima.

En [Gut84] se presenta el rendimiento de tres algoritmos para la división de nodos basados en minimizar el área total del MBR que cubre a los MBRs que estarían 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 número de posibles particiones igual a 2M – 1. Ya que para un conjunto de M + 1 elementos (nodo desbordado), hay 2M+1 posibles particiones. De entre todas ellas, eliminamos el conjunto vacío, el conjunto con M + 1 elementos, y todas las particiones duplicadas, obteniendo (2M+1 – 2)/2 = 2M – 1 particiones. Esta técnica es impracticable para la mayoría de los valores de M, puesto que la complejidad del algoritmo es de orden exponencial.

El segundo algoritmo tiene un coste cuadrático en M y lineal en el número de dimensiones k, e intenta encontrar una partición con un área lo suficientemente pequeña sin llegar a garantizar que determina la partición con el área más pequeña posible. Primero, encuentra los dos MBRs que generarían el área más 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 continuación, 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 añade a ellos. El objetivo principal es encontrar el MBR n tal que ∆ns – ∆nt tiene el valor máximo,

Capítulo 2

32

y entonces añadir el MBR n al nodo actual que provoque un aumento de área más pequeño. Todo este proceso se realiza para cada uno de los MBRs que vayan quedando de los M + 1 originales que había en el nodo desbordado.

El tercer algoritmo tiene un coste lineal en M y en el número de dimensiones k. Primero, encuentra los dos MBRs con la separación normalizada más grande a lo largo de todas las dimensiones. Por ejemplo, suponiendo que el origen está en la esquina superior izquierda del espacio, en la dimensión vertical están los MBRs con el lado inferior máximo y con el lado superior mínimo. Después, 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 añade.

En [Gut84] se muestran una serie de experimentos utilizando los tres algoritmos de división para consultas sobre los R-trees generados (análisis basado en tiempo de ejecución y en número de accesos a disco), llegando a la conclusión de que no hay grandes diferencias entre los tres. De esta manera, el algoritmo de división lineal (más rápido) se escogió como preferible aunque la calidad de la división 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, borrándose R de H si la búsqueda ha sido satisfactoria. Después, si el borrado del MBR no provoca que el número de entradas de H sea inferior a m (capacidad mínima del nodo), conocido como underflow, comprobamos si el mínimo rectángulo que lo cubre se puede reducir. Si es así, se realiza el ajuste apropiado y lo propagamos desde la hoja hacia la raíz. Por otro lado, si el borrado de R provoca que la capacidad del nodo sea inferior a m, entonces añadimos el contenido del nodo en una lista temporal T, y borramos este nodo del índice. Entonces, este proceso de borrado se propaga desde la raíz a las hojas realizando los ajustes necesarios de los MBRs. Si una vez alcanzada la raíz, ésta tiene sólo un hijo, entonces dicho hijo se convierte en la nueva raíz. Finalmente, reinsertamos todos los MBRs huérfanos de la lista temporal T en la raíz. 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 tenían en el R-tree antes de realizar el proceso de borrado, ya que de ellos dependen subárboles. Alternativamente, podemos mezclar los MBRs huérfanos con nodos hermanos como ocurren en los B+-trees, aunque en [Gut84] se utiliza la reinserción por dos motivos: (1) se puede hacer uso del algoritmo de inserción, y (2) este proceso refina incrementalmente la estructura espacial del árbol y evita el deterioro que ocurriría cuando se combinan entradas huérfanas con nodos adyacentes.

El algoritmo de búsqueda de MBRs u objetos en un R-tree no es difícil de llevar a la práctica. El único problema que surge cuando intentamos encontrar un determinado objeto es que puede ser necesario examinar varios caminos (subárboles), ya que puede haber solape entre MBRs a un mismo nivel y para encontrar el objeto en cuestión puede ser necesario recorrerlos todos ellos.


33

2.6.2 Características principales del R*-tree

El diseño del R*-tree como método de acceso espacial introduce una nueva política para la inserción denominada, reinserción forzada. En ella, si un nodo se desborda por primera vez en un determinado nivel, no se realiza la división del mismo de forma inmediata, sino que primero se extraen w entradas de dicho nodo y después se reinsertan en el R*-tree. El parámetro w puede variar, aunque en [BKS+90] se propuso establecer w al 30% del número máximo de entradas por nodo (w = 0.3 * M). Existen dos razones fundamentales para emplear la reinserción forzada. Primero, este proceso puede reducir considerablemente el número de divisiones de nodos desbordados. Segundo, la aplicación de esta técnica es muy importante para reorganizar dinámicamente el R*-tree.

Otro aspecto importante de los R*-trees está relacionado con la política de división de nodos desbordados (overflow). Mientras que en los R-trees convencionales presentados en [Gut84] sólo se trata de minimizar el área que cubre a las regiones de los nodos resultantes, el R*-tree también tiene en cuenta los siguientes objetivos:

1. Se debe minimizar el solape (overlap) entre regiones minimales cubiertas por nodos que están en el mismo nivel del árbol. Cuanto menor sea el solape entre MBRs, menor es la probabilidad de tener múltiples caminos de búsqueda.

2. Se debe minimizar también los perímetros de los MBRs. El MBR preferido es el que tiene forma cuadrada, ya que es la representación rectangular más compacta.

3. Se debe maximizar la utilización del almacenamiento.

Los algoritmos para la división de nodos en el R*-tree están basados en la técnica del Barrido del Plano (plane-sweep) [PrS88]. Para k dimensiones, la complejidad de los algoritmos de división 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 distribución de MBRs en los nodos. Por ello, el algoritmo de inserción de objetos en un R*-tree es la fase más importante de cara a tener un buen rendimiento para las consultas (árbol más compacto y reducido). El algoritmo de inserción de objetos en un R*-tree es completamente diferente al utilizado por los R-trees convencionales. Según [BKS93a, YuM98], las dos características 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 (desbordándose, con un total de M + 1 entradas) en el R*-tree, generalmente el nodo no se divide inmediatamente, sino que una fracción de sus entradas se extrae y se reinserta en el mismo nivel del R*-tree. Las entradas que se extraen para después reinsertarlas se seleccionan de forma que tengan la mayor distancia desde el centro del MBR original del nodo. La reinserción de entradas aumenta la utilización del almacenamiento mejorando la calidad de la división (reduciendo el solape entre MBRs) y hace que el rendimiento sea casi independiente de la secuencia de inserción. Si durante el proceso de reinserción 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 división de un nodo que indicamos a continuación.

Capítulo 2

34

En segundo lugar, el algoritmo para la división 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 dimensión donde se va a realizar la división. Para cada dimensión, se ordenan todas las entradas con respecto a los valores más 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 ordenación, M – 2m + 2 (donde M y m es la capacidad máxima y mínima de un nodo, respectivamente), y se suman los perímetros de los MBRs de todas las posibles particiones. Repetimos el mismo proceso con las entradas ordenadas respecto a los valores más altos de los intervalos en cada dimensión. La dimensión con el menor valor de suma de perímetros se escoge como eje de división. En segundo lugar (una vez seleccionado el eje de división), se considera de nuevo el conjunto con las M + 1 entradas ordenadas con respecto a los valores más bajos de los intervalos obtenidos de la proyección de los MBRs sobre el eje de división. Este conjunto se divide en dos subconjuntos, que se consideran como nodos diferentes del R*-tree. El número de entradas de un subconjunto y otro varía 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 más particiones tienen la misma mínima área de solape, entonces escogemos de todas ellas, la partición con la menor suma de área.

En [BKS+90] se presenta una amplia sección 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 según los siguientes parámetros comparativos: consultas para la localización de un punto, consultas en rango, inserciones y utilización del almacenamiento.

A continuación se van a describir los algoritmos de inserción, borrado y búsqueda de MBRs en un R*-tree, que se ilustrarán 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 páginas 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.


35

2.6.3 Algoritmos para el mantenimiento de un R*-tree

Como sabemos, los R*-trees son índices arbóreos que organizan dinámicamente un conjunto de objetos k-dimensionales representados por sus MBRs k-dimensionales. Al ser estructuras de datos dinámicas deben adaptarse al crecimiento o disminución de la información contenida en ellas de manera adecuada, siendo capaces de gestionar grandes volúmenes de datos de alta dimensionalidad. Por tanto, operaciones de inserción, borrado y búsqueda se deben de poder llevar a cabo sobre dichos métodos de acceso sin deteriorar el tiempo de procesamiento. En los siguientes epígrafes, se van a describir los algoritmos de inserción, borrado y búsqueda de MBRs en un R*-tree, que son la base para el mantenimiento de dicho índice arbóreo.

2.6.3.1 Algoritmo de inserción

Sea N un nodo interno de un R*-tree, cuando insertamos un MBR S, en un nodo hijo de N, se necesita escoger algún MBR, por ejemplo R, en N como el MBR padre de S. Puede que R necesite agrandarse para contener a S. Una técnica de optimización es escoger a R en N tal que necesite la menor expansión de solape para contener a S. Evidentemente, cuando R se agranda, el factor de solape de R en N es probable que se incremente. También es evidente que si R contiene ya a S, entonces no se necesita ninguna expansión para R. Minimizando el solape se tiende a minimizar el número de subárboles que hay que seguir para realizar las operaciones de búsqueda.

Definición. 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.

Capítulo 2

36

Para presentar la descripción del algoritmo de inserción en un R*-tree consideramos los siguientes parámetros: sea T el puntero a la raíz del R*-tree y (S, PS) el par a insertar, donde PS es la dirección del puntero al elemento (nodo u objeto) que cubre al MBR S. Además debemos considerar a L, que inicialmente es el nodo raíz, como el nivel donde va a ser insertado el par (S, PS). 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 están desactivados.

Insertar(S, PS, L, T)

1. Seleccionar un nodo N en el nivel L para insertar S. Esto se lleva a cabo recursivamente desde el nodo raíz hasta el nodo con nivel L. Si N es un nodo en el nivel L, devuelve N. En otro caso, se selecciona un subárbol 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 expansión de solape para contener a S. Si varios MBRs en N necesitan la misma expansión de solape para contener a S, se escoge el MBR cuya área necesita la menor expansión 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 expansión 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 expansión para contener a S. Si existen varios MBRs con la menor área de expansión 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 selección 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 número de entradas de N es menor o igual que M, siendo M la capacidad máxima de un nodo) al par (S, PS), lo insertamos en N y salimos del procedimiento. En otro caso se produce un desbordamiento (el número 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á aún desactivado) y N no es el nodo raíz, 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 raíz del R*-tree tendrá siempre un solo nodo, la reinserción a este nivel no tiene sentido. Por tanto, si N es el nodo raíz 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 reinserción. 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 continuación, se ordenan las M + 1 entradas en orden descendiente de las distancias. Las primeras w


37

entradas en esta lista de M + 1 entradas se escogen para la reinserción, y el MBR del nodo interno se ajustará convenientemente (reduciendo su tamaño). Esta selección tiende a mantener los MBRs que no se consideran para la reinserción tan cercanos como sea posible. Los experimentos llevados a cabo en [BKS+90] mostraron que w = 0.3*M es una buena elección. Sea (Si, PSi) para i = 1, 2, ...,w las entradas seleccionadas para la reinserción. Se reinsertan todas estas entradas en orden ascendente de sus distancias llamando a Insertar(Si, PSi, L, T), i = w, w-1, ...,1. Los resultados experimentales llevados a cabo en [BKS+90] demostraron que la reinserción 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 distribución en dos nodos. La restricción que debe cumplirse es que cada nodo necesita tener al menos m entradas. Los pasos para el algoritmo de división se describen a continuación.

5.1. Para la i-ésima dimensión en el espacio k-dimensional (1≤i≤k), ordenamos las M + 1 entradas, primero por los valores más bajos y después por los valores más 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 partición, 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 aclaración, 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 después en el segundo conjunto de acuerdo con el orden establecido. Para la j-ésima partición, sea bj1 y bj2 los MBRs de los rectángulos minimales en el primer conjunto y en el segundo conjunto, respectivamente. Sean pj1 y pj2 los perímetros de bj1 y bj2, respectivamente. Denotemos Xi como la suma de los perímetros de todos los MBRs para la dimensión i-ésima (1≤i≤k, ya que tenemos k dimensiones), donde pij1 y pij2 representan la aportación en la dimensión i al perímetro de pj1 y pj2 de la j-ésima partición, respectivamente. La expresión Xi de es la siguiente:

( ) ki1 ppXmM

jijiji ≤≤∀= ∑

+−

=

, ,22

121

La dimensión con valor Xi más pequeño es denominada eje de división. Solo se consideran las particiones basadas en la ordenación sobre el eje de división para identificar la mejor partición. Para minimizar aún más los valores de los perímetros, los MBRs de los nodos internos tienen la tendencia a convertirse en cuadrados, ya que los cuadrados pueden agruparse más fácilmente.

5.2. Entre las M – 2m + 2 particiones a lo largo del eje de división, encontramos la partición con la menor área de solape entre bj1 y bj2. Si dos o más particiones tienen la misma mínima área de solape, entonces escogemos de entre todas ellas, la partición con la menor suma de área.

Capítulo 2

38

5.3. Dividir las M + 1 entradas basadas en la partición escogida en 5.2 y utilizar los dos nuevos nodos para reemplazar en nodo N. Dos nuevas entradas (de la forma (S, PS)) correspondientes a los dos nuevos nodos se generarán para el nodo padre de N (NP) 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 NP para esta nueva entrada, se reemplaza la antigua por una de las nuevas y la restante se añade al nodo NP, y finaliza el algoritmo. En otro caso (desbordamiento en el nodo padre de N, NP), sustituimos N por NP, 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 reinserción o el algoritmo de división debería aplicarse para gestionar el desbordamiento en el nodo padre, NP. La división de un nodo desbordado puede propagarse a todos los niveles hasta llegar al nodo raíz. Si el nodo raíz necesita dividirse, entonces se debe crear un nuevo nodo raíz y la altura del árbol R*-tree se incrementa en 1.

Para mostrar un ejemplo de inserción 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 línea 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 inserción empezamos por el nodo raíz 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 raíz cuyo MBR necesita tener una menor expansión de solape para contener el MBR R9. Supongamos que el MBR R21 cuya entrada es (R21, PR21), es el MBR que verifica dicha condición. Seguimos el R*-tree por el puntero asociado al MBR R21, que denominamos PR21, y descubrimos que es el nodo hoja más 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, PR9), 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 reinserción. Supongamos que seleccionamos la entrada correspondiente al MBR R1 (R1, PR1) para la reinserción. 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 reinserción nos vuelve a causar otro desbordamiento a nivel de hoja. Esta vez necesitamos aplicar el proceso de división sobre las cuatro entradas que hay (tres anteriores {R9, R2, R3}, más la nueva entrada que ha sido reinsertada (R1, PR1)) 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 Inserción del MBR R9.


39

Para empezar con el proceso de división del nodo desbordado tenemos que ordenar las cuatro entradas a lo largo del eje X (dimensión 1) dando lugar a {R1, R9, R2, R3}, y a lo largo del eje Y (dimensión 2) quedando {R9, R3, R1, R2}. En nuestro ejemplo, por cada eje (dimensión) sólo 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 ordenación a lo largo del eje X, la partición resultante sería {(R1, R9), (R2, R3)}. Para la ordenación a lo largo del eje Y tendríamos la siguiente partición {(R9, R3), (R1, R2)}. Claramente, según la Figura 2.9.b, la suma de los perímetros de los MBRs de (R1, R9) y de (R2, R3) es menor que la suma de los perímetros de (R9, R3) y de (R1, R2). Por tanto el eje X es el que escogemos como eje de división. Una vez terminado el proceso de división, tenemos dos nuevos nodos {R1, R9} y {R2, R3} que se crearán 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, PR24) y (R25, PR25) se crearán para ubicarlas en el nodo raíz y reemplazarlas por la entrada (R21, PR21) que aparece en la Figura Fig. 2.7.b. Debido que no hay suficiente espacio en el nodo raíz para contener las cuatro entradas {R24, R25, R22, R23} se produce un nuevo desbordamiento, pero esta vez a nivel del nodo raíz. Debido a que nos encontramos en el nivel del nodo raíz, el proceso de reinserción ahora no se realiza y en su lugar llevamos a cabo el proceso de división del nodo desbordado (nodo raíz). Utilizando el mismo método que se ha descrito anteriormente a nivel de hoja, llevamos a cabo una partición a lo largo del eje Y, seleccionando a éste como eje de división. Como resultado de este proceso obtenemos que el nodo raíz 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 raíz {R26, R27} con sus respectivas entradas (R26, PR26) y (R27, PR27), y la altura del árbol se incrementa en 1. El resultado final de la inserción 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 páginas 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 Distribución de los MBRs y el R*-tree asociado después de insertar el MBR R9.

Capítulo 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 debería 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 número de entradas del nodo sea inferior a m (capacidad mínima del nodo), conocido como underflow. Mejor que redistribuir el nodo con un número 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 huérfanas) se reinsertan en el R*-tree. El borrado de un nodo provoca la eliminación de una entrada en el nodo padre. El algoritmo de borrado se diseña 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 número de entradas menor que m (underflow). Este underflow puede propagarse hasta el nodo raíz y decrementar en 1 la altura del R*-tree.

Para presentar el algoritmo de borrado en un R*-tree consideramos los siguientes parámetros: sea T el puntero al nodo raíz 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 raíz y S es un MBR que cubre un objeto.

Borrar(S, L, T)

1. Encontrar el nodo en el nivel L que debería contener a S. Esto puede llevarse a cabo como indicamos a continuación. 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 más entradas después de borrar S, ajustamos el MBR de N en el nodo padre de N (NP) con todos los MBRs que tiene en ese momento y salimos del algoritmo. Si N tiene sólo m – 1 entradas después de borrar S, tratamos el underflow como se indica en el paso 3.

3. Tratamiento del underflow (la ocupación 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(SP, LP, T), donde SP es el MBR de N y LP es el nivel del padre con respecto al nivel L. Si el nodo original del padre de N es el nodo raíz y éste tiene un único nodo hijo después de borrar el nodo N, hacemos que dicho nodo hijo sea ahora el nuevo nodo raíz.


41

3.2. Segundo, llamamos a la función Insertar(Si, PSi, L, T) para insertar en el R*-tree cada una de las m – 1 entradas restantes de N (entradas huérfanas), donde cada entrada es de la forma, (Si, PSi) para i = 1, 2, ..., m – 1.

2.6.3.3 Algoritmo de búsqueda

Cuando queremos realizar consultas que utilizan métodos 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 búsquedas en rango (también 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 raíz 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 también 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 debería seguir hasta que los MBRs hijos de R puedan examinarse con respecto a S. Evidentemente, este proceso debería repetirse para cada una de las entradas en N cuyos MBRs se solapan con S. Además, debemos tener en cuenta que al no existir ningún 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 búsqueda. Es decir, que si algún nodo en el R*-tree se alcanza durante el proceso de búsqueda, entonces todas las entradas de dicho nodo deben examinarse.

Para presentar el algoritmo de búsqueda en rango sobre un R*-tree definido en un espacio bidimensional de datos, debemos considerar los siguientes parámetros: sea T el puntero al nodo raíz del R*-tree y, S denota el MBR definido para la consulta en rango {(x_windowmin, y_windowmin), (x_windowmax, y_windowmax)}.

Buscar(S, T)

1. Si PN es un puntero a un nodo interno, comprobamos cada entrada (R, P) en el nodo apuntado por PN para determinar si R se solapa con S. Los MBRs están definidos en el espacio bidimensional. R = {(xmin, ymin), (xmax, ymax)}, donde (xmin, ymin) es el punto del MBR R situado en la esquina inferior izquierda, y (xmax, ymax) es el punto del MBR R situado en la esquina superior derecha. Y S = {(x_windowmin, y_windowmin), (x_windowmax, y_windowmax)}, donde (x_windowmin, y_windowmin) es el punto del MBR S situado en la esquina inferior izquierda, y (x_windowmax, y_windowmax) es el punto del MBR S situado en la esquina superior derecha. R y S se solapan si se verifican las siguientes condiciones: x_windowmin ≤ xmax, y_windowmin ≤ ymax, x_windowmax ≥ xmin e y_windowmax ≥ ymin. Si R se solapa con S, recursivamente comprobamos todas las entradas en el nodo hijo llamando a la función Buscar(S, P).

2. Si PN es un puntero a un nodo hoja, comprobamos cada entrada (R, P) en el nodo hoja apuntado por PN para determinar si R se solapa con S. Si R se solapa efectivamente con

Capítulo 2

42

S, entonces devolvemos R como un MBR de un objeto que verifica la condición de búsqueda en rango (solaparse con S).

En la Figura 2.11 mostramos un ejemplo de búsqueda 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 búsqueda 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 Búsqueda en rango para MBRs de objetos que se solapan con S.

2.6.4 Algoritmos para el procesamiento de consultas utilizando R*-trees como método de acceso espacial

Después de introducir a la familia de los métodos de indexación 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 más importantes utilizando dichos índices [GaG98].

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

La utilización de MBRs como aproximaciones de objetos espaciales proporciona un rápido pero inexacto filtro para obtener un conjunto respuesta a petición 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 pequeño, muy próximo al grande, sin que haya solape entre ellos.


43

Utilizando los MBRs como aproximación de los objetos espaciales, en lugar de la representación exacta de dichos objetos, los vamos a indexar en un método 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

Comprobación con la geometría exacta

Falsos Aciertos

Aciertos

Resultado de la consulta

Fase de Filtrado Fase de Refinamiento

*Dataset = Conjunto de objetos espaciales +MAE = Método 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, además, objetos que no satisfacen el predicado espacial. Después, 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 añadirse 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 también que en la etapa de filtrado pueden combinarse varios métodos de acceso espaciales en base a una propiedad espacial y no sólo uno como se muestra en la gráfica, como por ejemplo para realizar un join espacial entre dos conjuntos de objetos espaciales.

Segunda fase, denominada etapa de refinamiento (refinement step), también conocida como etapa de procesamiento geométrico exacto. En esta fase tomamos el conjunto de candidatos de la etapa de filtrado y exploramos si la geometría exacta de estos objetos satisface el predicado espacial o no. Esta etapa es bastante costosa, ya que debe gestionar la geometría exacta de los objetos utilizando eficientes algoritmos de geometría 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 añaden directamente al conjunto solución final

Capítulo 2

44

de la consulta, y (2) Falsos Aciertos (false hits) que no satisfacen el predicado espacial, siendo automáticamente descartados. Es decir, en esta etapa si la evaluación del predicado espacial es cierta para la geometría exacta del objeto espacial, entonces añadiremos el objeto al resultado final de la consulta; en caso contrario, tendremos un falso acierto (false hit) que será automáticamente descartado.

En los algoritmos que se presenten a continuación para realizar las consultas espaciales más importantes utilizando R*-trees, nos vamos a ocupar sólo de los objetos o pares de objetos candidatos después de realizar la etapa de filtrado y no profundizaremos en la segunda etapa (etapa de refinamiento), ya que tendríamos que hacer uso de algoritmos geométricos para determinar los objetos que pertenecen al conjunto solución exacto según un predicado espacial determinado, y estos algoritmos quedan fuera del alcance de este trabajo de investigación.

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

En el epígrafe 2.5 se definieron formalmente los tipos de consultas espaciales más representativas. En esta sección, vamos a presentar los algoritmos para realizar dichas consultas utilizando R*-trees como método de acceso espacial.

Los tipos de consultas espaciales más importantes son los siguientes:

1. Consulta Exacta (Exact Query). La consulta para la Localización de un Punto (Point Location Query) es un caso particular de Consulta Exacta.

2. Consulta en Rango (Range Query).

3. Consulta del Vecino más Próximo (Nearest Neighbor Query).

4. Join Espacial (Spatial Join).

La mayoría de los algoritmos para realizar consultas espaciales utilizando R*-trees están basados en el recorrido recursivo en profundidad del árbol. La idea básica es leer un nodo del árbol y realizar la operación 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,


45

necesitamos leer del archivo de datos la geometría 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 mínimo rectángulo que cubre al objeto y OBJ describe la geometría 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(pi.MBR, Obj.MBR) then 04 nP’ = LeerNodo(pi.direccion); 05 ConsultaExacta(nP’, Obj); 06 endif 07 enddo 08 else 09 for every entrada p i de nP do 10 if solapa(pi.MBR, Obj.MBR) then 11 Objeto = LeerObjeto(pi.direccion); 12 if igual(Objeto, Obj.OBJ) then 13 return true; 14 endif 15 endif 16 enddo 17 endif

El siguiente algoritmo determina la consulta para la localización de un punto. Para este caso, suponemos que en las hojas están 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(pi.MBR, p) then 04 nP’ = LeerNodo(pi.direccion); 05 ConsultaLocalizacionPunto(nP’, p); 06 endif 07 enddo 08 else 09 for every entrada p i de nP do 10 if igual(pi.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.

Capítulo 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(pi.MBR, k_R) then 04 nP’ = LeerNodo(pi.direccion); 05 ConsultaRango1(nP’, k_R); 06 endif 07 enddo 08 else 09 for every entrada p i de nP do 10 if solapa(pi.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, determinándose todos los objetos que se solapan con el rango de distancia generado por ellos. Para desarrollar el algoritmo debemos utilizar la función de distancia MINDIST definida en [RKV95], que obtiene el mínimo valor de distancia entre un punto y un MBR en el espacio Euclídeo 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(pi.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 acción 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 más próximo

La consulta para determinar el vecino más próximo (CVP) o los K vecinos más próximos (K-CVP) utilizando estructuras de datos jerárquicas y arbóreas es posiblemente la consulta más estudiada por los investigadores. [Ben75, FBF77, MuS86, Bro90, Spr91] para k-d-trees,


47

[HjS95, HoS91] para Quadtrees y sus variantes, y [RKV95, PaM97, ChF98, PaM98, HjS99] para R-trees son los trabajos más representativos.

El algoritmo más conocido es el algoritmo branch-and-bound recursivo propuesto en [RKV95]. Para encontrar el vecino más próximo a un objeto dado a priori utilizando R*-trees, el algoritmo empieza desde la raíz del árbol y va descendiendo hasta las hojas. La idea fundamental del algoritmo es que muchas ramas del árbol pueden ser descartadas siguiendo unas heurísticas de poda basadas en unas métricas denominadas MINDIST y MINMAXDIST (sólo para el caso que se pretenda encontrar el vecino más próximo) entre un punto p = (p1, p2, ..., pk) y un MBR definido por dos puntos, k_R, en el espacio Euclídeo k-dimensional. MINDIST representa el mínimo valor de distancia entre un punto y un MBR, y MINMAXDIST es la máxima distancia entre un punto y la cara más próxima de un MBR; las fórmulas para su cálculo se verán con mayor detalle en el capítulo 3.

El algoritmo que mostramos a continuación encuentra el vecino más próximo 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 características 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 = pi.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 = pi; 25 endif 26 enddo 27 endif

Para procesar el caso general del vecino más próximo (obtener los K vecinos más próximos) debemos mantener una estructura de datos adicional en la que estén almacenados los K vecinos más próximos procesados hasta el momento. El mecanismo de poda de MBRs no se realiza utilizando MinMaxDist como sucede para el caso del vecino más próximo, sino que se debe llevar a cabo según la distancia del elemento más lejano de los vecinos más

Capítulo 2

48

próximos almacenados hasta el momento en la estructura de datos auxiliar (es decir, el K-ésimo vecino más próximo encontrado hasta el momento). Es importante destacar que la estructura de datos que se utiliza es un montículo (heap) de elementos en el que la distancia mayor es la del elemento situado en la raíz (montículo máximo). Al principio todos los elementos del montículo adicional deben estar inicializados a ∞.

En [HjS99] presentan un algoritmo general basado en [HjS95] para encontrar el vecino más próximo de una forma incremental e iterativa utilizando R-trees. Este algoritmo es incremental en el sentido de que habiendo obtenido los K vecinos más próximos, el (K + 1)-ésimo vecino puede obtenerse sin tener que calcular desde el principio los K + 1 vecinos más próximos. Además, el usuario obtiene parte del resultado antes de la finalización del algoritmo, pudiendo detener éste en el momento que considere oportuno.

La versión incremental e iterativa para encontrar el vecino más próximo decide qué nodo va a procesar a continuación, 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 montículo) donde la distancia entre el punto de consulta y los elementos del R-tree se utiliza como clave, y además 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 número de nodos a procesar.

El algoritmo que mostramos a continuación encuentra el vecino más próximo a un punto dado, suponiendo que el R*-tree almacena puntos en sus hojas. Éste tiene como característica que es un algoritmo Iterativo e Incremental.

CVP_Incremental(Raíz: 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.dirección_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


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), pi.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 línea 5 del algoritmo CVP_Incremental se ha colocado la condición VP_retornados < 1 con el objetivo de devolver como resultado sólo el vecino más próximo. La extensión de este algoritmo para encontrar los K vecinos más próximos es sencilla, ya que las únicas modificaciones que se deben hacer son: (1) no utilizar la métrica MINMAXDIST cuando se están procesando MBRs del R-tree en el rango de líneas 21-26, (2) aplicar la condición 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 líneas 15 y 28, junto con la inicialización y actualización de T en las líneas 2, 16 y24.

Existe una importante diferencia entre los algoritmos iterativos incrementales y no incrementales. Los algoritmos iterativos e incrementales devuelven los objetos más próximos al punto dado, uno a uno (si devuelve al K-ésimo vecino más próximo, 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 montículo principal los MBRs del R*-tree, procesando en las hojas todos los puntos o MBRs de los objetos, y se insertan en un montículo máximo adicional de tamaño K los que tienen una distancia mínima menor que la distancia del elemento ubicado en la raíz del montículo. Cabe destacar que la suma de elementos insertados en los dos montículos (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 epígrafe 2.5 la definición 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 evaluación del predicado espacial Θ(O.geo, O’.geo) es cierta.

Capítulo 2

50

JE(P, Q, Θ) = {(O, O’) ∈ P×Q : Θ(O.geo, O’.geo)}

Para el predicado espacial Θ existe una amplia gama de posibilidades. El join espacial es una operación 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 clasificación del Join Espacial en tres categorías 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 ningún índice sobre los conjuntos de objetos espaciales se han propuesto varias técnicas de división del espacio en cubetas (buckets) y después aplicar técnicas dispersión (hashing) o línea de barrido (sweep-line), [ArS94, GüS89, 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 combinación del Barrido del Plano [PrS85] y la división del espacio para realizar el join, trabajando bajo la suposición de que en la mayoría de los casos el final de la línea de barrido puede almacenarse en memoria principal. Sin embargo, el algoritmo no puede evitar la ordenación externa de ambos conjuntos de datos, lo cual puede generar una gran sobrecarga de operaciones de E/S (número de accesos a disco). En [PaD96] se describe un algoritmo para el join por dispersión (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 técnica de Barrido del Plano para generar el resultado del join. Algunos objetos de ambos conjuntos de datos de entrada pueden asignarse en más de una partición. Por ello, el algoritmo necesita ordenar el resultado para eliminar pares duplicados. Otro algoritmo basado en la descomposición regular del espacio es el join espacial por separación de tamaño (size separation spatial join) [KoS97], que evita la duplicidad de objetos durante la fase de partición, introduciendo más de un nivel de partición. Cada objeto es asignado a una única partición, pero una partición puede ser enlazada con varios niveles superiores. Normalmente, el número de niveles es lo suficientemente pequeño para que una partición 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 dispersión (spatial hash join) [LoR96] evita resultados duplicados ejecutando una descomposición del espacio irregular, basada en la distribución de los datos de entrada.

Dos índices. Cuando tenemos dos conjuntos de objetos indexados, los algoritmos que han sido presentados dependen del método de indexación utilizado. [Ore86] es el primer trabajo conocido sobre join espacial, proponiendo un orden 1-dimensional de objetos espaciales cuyos códigos son indexados dinámicamente en un B+-tree y combinados en función de un predicado espacial, siguiendo un esquema de join en ordenación y mezcla (sort-merge join). Este esquema utiliza una rejilla para dividir de forma regular el espacio multidimensional en bloques pequeños, 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 dinámica utilizando estructuras de índice unidimensionales, como el B+-tree, y el join espacial se ejecuta siguiendo un esquema de ordenación y mezcla (sort-merge join). El rendimiento del algoritmo depende de la


51

granularidad de la rejilla, ya que rejillas con mucha precisión 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. [Gün93] 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 métodos de acceso espaciales y de predicados espaciales. El algoritmo de [BKS93a] es el más popular de los que realizan un recorrido sincronizado de los árboles en profundidad para el predicado espacial solapa utilizando R*-trees, por su eficiencia. Además, introduce una serie de técnicas avanzadas sobre el algoritmo, aplicadas de forma local para reducir y optimizar los costes de CPU (Barrido del Plano) y número de accesos a disco (restricción del espacio de búsqueda). 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 síncrona siguiendo una política de recorrido en anchura, donde es necesario procesar todos los pares de un nivel antes de procesar los pares de niveles más bajos. En cada nivel, BFRJ genera un resultado intermedio del join y utiliza técnicas de optimización global (ordenación, gestión de memoria y gestión del buffer) para mejorar el cálculo del join en el siguiente nivel. En [HjS98] se introduce un nuevo tipo de Join Espacial Basado en Distancias cuyo conjunto solución de pares ordenados se obtiene de forma incremental e iterativa. Se plantean tres variantes del algoritmo incremental e iterativo (Basic, Evenly y Simultaneous) según la política con que se recorran los R*-trees. En [SML00] se presentan varias mejoras al algoritmo original de [HjS98]. También debemos indicar que en [HoS95] se presenta un método 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 relación no está indexado, la estrategia más 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 según 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 construcción de un segundo índice ligado al conjunto de objetos espaciales no indexado. Basándose 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 aproximación 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 según estén o no indexados los conjuntos de datos que intervienen en la consulta.

Capítulo 2

52

Ambas entradas están indexadas Una entrada está indexada Ninguna entrada está indexada

Transformación a z-valores [Ore86] Examinar + Consulta en Rango Join espacial por dispersión [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 [Gün93, BKS93a, HoS95, HJR97a, HjS98, SML00]

Construir y emparejar [PaD96] Join espacial por separación de tamaño [KoS97]

Ordenar y emparejar [PRS99] Join espacial basado en un barrido escalable [APR+98]

Tabla 2.3 Clasificación de los métodos de join espacial.

En general, la indexación hace más eficiente el procesamiento del join espacial, un algoritmo que utiliza índices se espera que sea más eficiente que uno que no los considere. El rendimiento relativo dentro de la misma clase depende de las características del problema. En [Güt93], 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 métodos, puesto que evita la construcción de un R-tree. Para los algoritmos que no utilizan ningún índice no existe una evaluación experimental concluyente. Cada uno de los algoritmos posee ciertas ventajas respecto de los otros que lo hacen más apropiado en determinadas situaciones. Por ejemplo, el algoritmo presentado en [PaD96] es el más apropiado para el procesamiento de múltiples joins en paralelo, ya que utiliza particiones con extensiones fijas.

Nosotros nos centraremos en los algoritmos más importantes para el join espacial en el que los dos conjuntos de objetos están indexados (segunda categoría), utilizando R*-trees. En [BKS93a] se presenta una técnica para realizar el join espacial siguiendo un recorrido sincronizado en profundidad sobre los dos R*-trees. La idea básica es leer dos nodos, uno de cada árbol, y realizar la operación 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 RP y RQ que indexan los conjuntos de objetos P y Q, respectivamente El algoritmo realiza la combinación entre las entradas de los dos nodos nP y nQ, devuelve como resultado un conjunto de pares <pi, qj> que verifiquen el predicado espacial solapa tal que pi.MBR ∩ qj.MBR ≠ ∅. La primera aproximación 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 ∩ qj.MBR ≠ ∅ do 03 if nP es un nodo HOJA then 04 JE_Lista.insertar(<p i, qj>); 05 else 06 nP’ = LeerNodo(pi.direccion); 07 nQ’ = LeerNodo(qi.direccion); 08 JoinEspacial(nP’, nQ’); 09 endif 10 enddo 11 enddo


53

En [BKS93a] se presentan también dos técnicas de optimización local con el objetivo de reducir el tiempo de CPU y el número de accesos a disco (operaciones de E/S) sobre dicha consulta. Las técnicas son denominadas: restricción del espacio de búsqueda y Barrido del Plano [PrS88].

Restricción del espacio de búsqueda. 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 vacía (nP.MBR ∩ nQ.MBR ≠ ∅), entonces ese área es en sí un MBR (denominado MBR-solape). El procesamiento en líneas generales es el siguiente: si una entrada <pi.direccion, pi.MBR>x en nP se solapa con una entrada <qj.direccion, qj.MBR>y en nQ (pi.MBRx ∩ qj.MBRy ≠ ∅), 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 optimización es similar a la técnica del join por ordenación-mezcla (sort-merge join) utilizado para realizar el join entre dos conjuntos de objetos. Esta optimización 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 optimización utilizando la técnica 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 (pi.MBRx y qj.MBRx), respectivamente. Y segundo, en el proceso de mezcla, se examinan los MBR de los dos nodos ordenados según su coordenada X de forma secuencial, y para cada MBR (por ejemplo, pi.MBRx) se comprueba el solape con los MBRs de las entradas del otro nodo según su coordenada X (qj.MBRx).

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 política 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 sólo es necesario cuando el MBR del nodo padre de nP se solapa con el MBR del nodo padre de nQ. En [BKS93a] la eliminación de candidatos se realiza recorriendo los dos árboles de manera síncrona 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 continuación destacando que RP y RQ 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 <pi, qi> candidatos en el nivel i), y <pi.direccion, qi.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(<pi.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];

Capítulo 2

54

Debemos destacar que la función Node_Pair_Join(<pi.direccion, qi.direccion>) lee del disco los nodos apuntados por pi.direccion y qi.direccion e inserta en un conjunto temporal, tempIJI[i], todos los pares <pi+1, qi+1> que satisfacen el predicado espacial solapa.

En cada nivel, BFRJ genera un resultado intermedio del join en el nivel i después de que todos los nodos de RP en el nivel i han sido relacionados mediante el predicado espacial solapa con todos los nodos de RQ en el mismo nivel. La selección de los nodos de RP y RQ 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 técnicas de optimización global sobre la estructura IJI como son: ordenación, gestión de memoria y gestión del buffer.

Ordenación de la estructura intermedia del join entre los índices. Como en IJI[i] hay pares de la forma <pi, qi> en el nivel i, procedentes de los R*-trees de RP y RQ. El objetivo es mantener dichos elementos siguiendo un orden. En [HJR97a] se proponen 5 políticas de ordenación: (1) No aplicar ningún tipo de ordenación (OrdNon). (2) Ordenar los elementos de uno de los R*-trees (OrdOne), que consiste en ordenar los elementos pi del R*-tree de P (RP) según los valores de la coordenada del eje X. (3) Ordenar según la suma de los centros (OrdSum), calculando el centro de los MBRs de pi y qi según los valores de sus coordenadas del eje X y después suma dichos valores para obtener el valor a ordenar. (4) Ordenar según el punto central del MBR envolvente (OrdCen), para desarrollar esta estrategia de ordenación primero genera el MBR que envuelve a pi.MBR y qi.MBR calculando posteriormente el centro según 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] según dichos valores.

Gestión 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 ordenación de la misma tanto en memoria (OrdMem) como en disco (OrdDis) con el objetivo de minimizar el número de operaciones de E/S (accesos a disco).

Gestión del buffer de la estructura intermedia del join entre índices. Esta última estrategia de optimización global está basada en la implementación de un gestor del buffer bajo una extensión de la política de reemplazo de página LRU. Dicho gestor implementa las operaciones básicas para la manipulación de páginas en el buffer que denomina pin (marca la página para retenerla en el buffer LRU hasta que se realiza una operación upin), upin (elimina la marca pin) y purge (elimina una página del buffer LRU y la inserta en una lista de páginas libres).

La diferencia más 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 optimización 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 página. Mientras que en el algoritmo que sigue un recorrido sincronizado en profundidad, estos accesos redundantes ocurren en la fase de backtracking.


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 aplicación de esta operación es encontrar los pares más 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 Euclídeo k-dimensional, y especifica un orden (en ranking) sobre los elementos del conjunto final basado en la distancia Euclídea. Dicho algoritmo es iterativo puesto que utiliza una cola de prioridad (implementada como un montículo) 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 (característica de los algoritmos no incrementales). En general, el mecanismo para calcular esta consulta es como aplicar de forma simultánea al algoritmo incremental del vecino más próximo presentado en [HjS95], a dos estructuras de datos arbóreas multidimensionales.

En [HjS98] también se presentan variantes de los mismos para realizar la operación de Semi-Join Basado en Distancias, en el sentido de que el resultado de dicha operación es un subconjunto del Join Basado en Distancias, donde un par de objetos espaciales <pi, qi> aparece en el conjunto resultado sólo si ninguno de los restantes pares tiene como primer componente a pi. Es decir, que en el conjunto resultado para esta operación van a estar formado por todos los pares <pi, qi> donde cada objeto pi ∈ P está ligado con el objeto más cercano qi ∈ Q. Evidentemente, la cardinalidad del conjunto resultado para el Semi-Join Basado en Distancias será P. Un ejemplo para esta consulta sería determinar los pares (tienda, almacén), tal que una vez encontrado el almacén más cercano a una tienda, dicha tienda ya no interviene más 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 RP y RQ. Dicho algoritmo mantiene un conjunto de pares M, con un elemento de RP y otro de RQ, 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 raíz de RP y RQ. El conjunto de todos los pares (producto cartesiano de todos los elementos de RP y RQ) 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), después 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 estén todos los posibles pares de elementos (producto cartesiano) que se pueden formar de RP y RQ. El algoritmo esencialmente calcula M de la forma anteriormente descrita, con la restricción de que los pares se organizan según sus mínimas 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 básica (Basic) del algoritmo, se extrae el par que está al principio de la cola de prioridad, es decir, el par con la mínima distancia. Si el elemento que está al principio de la cola de prioridad almacena un par de objetos <o1, o2>, entonces dicho par es devuelto como el siguiente par más cercano. Debido al funcionamiento del algoritmo y a la forma de gestionar los elementos almacenados en la cola de prioridad, ningún par de objetos que se devuelva posteriormente tendrá una mínima distancia menor que la del último par de objetos devuelto. Además, por las restricciones de consistencia de las funciones de

Capítulo 2

56

distancia (d(MBR1, OBJ2) ≤ d(OBJ1, OBJ2), por la definición de MBR) se garantiza que ningún par en la cola de prioridad dará lugar a un par de objetos con una distancia estrictamente más pequeña. 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 continuación, se presenta el algoritmo en su variante básica (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


57

Las tres variantes del algoritmo que se presentan en [HjS98] se clasifican en función de la política con que recorren los R*-trees. Si la prioridad se le da arbitrariamente a uno de los dos R*-trees (por ejemplo, a RP) 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 también extensiones del algoritmo para determinar los K pares más cercanos (siendo en este caso incremental hasta K) y Semi-Join Basado en Distancias. Para llevar a cabo la primera extensión utiliza la máxima distancia de los elementos que componen un par, junto con estructuras de datos adicionales (cola de prioridad en la que la principio está el máximo valor y tabla hash). Para la segunda de las extensiones presenta seis aproximaciones para realizar dicha operación, junto con estructuras de datos adicionales para almacenar elementos de uno de los R*-trees (objetos y MBRs o sólo objetos).

En [SML00] se presentan mejoras a [HjS98] utilizando la técnica de Barrido del Plano junto con un esquema multietapa basado en montículos adicionales para obtener el conjunto solución del Join Basado en Distancias de manera incremental e iterativa. En este trabajo demostraron empíricamente mejorar considerablemente los resultados presentados en [HjS98] respecto al número de accesos a disco, cálculo de distancias y tiempo de respuesta.

Para finalizar con esta revisión de los algoritmos más representativos que realizan la operación 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 operación se utilizan heurísticas y un esquema de buffering complejo, tratando de reducir al máximo el número de accesos a disco. Antes de empezar con el procesamiento del algoritmo, es necesario realizar una normalización de los espacios que cubren los dos métodos de acceso que intervienen en la consulta.

2.7 Conclusiones

En el presente capítulo hemos estudiado los métodos de acceso espaciales basados en MBRs, prestando especial atención al R*-tree. Para ello, hemos revisado y clasificado los métodos de acceso multidimensionales más conocidos. A continuación, se ha estudiado el modelo de organización de índices basados en MBRs en un espacio de datos multidimensional, que es la base para el diseño de algoritmos de creación métodos de indexación pertenecientes a la familia de los R-tree k-dimensionales.

El R*-tree, como método de acceso espacial basado en MBRs y perteneciente a la familia de los R-tree k-dimensionales, añade fundamentalmente dos mejoras al R-tree convencional cuando sucede el desbordamiento de un nodo en el algoritmo de inserción. La primera, en

Capítulo 2

58

lugar de considerar el área, el algoritmo de división del R*-tree intenta minimizar el perímetro y el solape de los MBRs expandidos de un nodo. Al minimizarse el solape, se reduce el número de subárboles a explorar para las operaciones de búsqueda. La segunda mejora consiste en introducir el concepto de reinserción forzada, para que la estructura del árbol sea menos dependiente del orden de inserción, y dando lugar a un árbol más compacto. Cuando un nodo se desborda, no se divide inmediatamente, sino que una parte de las entradas del nodo se reinsertan de nuevo. La reinserción proporciona dos importantes mejoras: (1) se reduce el número de divisiones de los nodos y, (2) es una técnica para reorganizar el árbol de forma dinámica. 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 creación de métodos de acceso para organizar datos multidimensionales, como diseñar algoritmos eficientes para el procesamiento de consultas sobre ellos. Por este motivo, definimos las consultas espaciales más representativas y diseñamos los algoritmos que las implementan sobre el R*-tree, revisando el estado del arte actual en este campo. Las consultas espaciales más importantes sobre las que hemos diseñado algoritmos, utilizando el R*-tree como método de acceso espacial, han sido las siguientes: (1) consulta exacta y la consulta para la localización de un punto, (2) consultas en rango, (3) consulta del vecino más próximo, y (4) join espacial.

59

Capítulo 3

CONSULTAS DE LOS PARES MÁS CERCANOS

3.1 Introducción

La mayoría de los trabajos de investigación dedicados al estudio de las consultas basadas en distancias sobre métodos de acceso multidimensionales se han centrado casi exclusivamente en optimizar la consulta del vecino más próximo o su extensión para los K vecinos más próximos, mejorando tanto las estructuras de datos utilizadas como los algoritmos que las llevan a cabo. Recientemente, se están diseñando algoritmos para el procesamiento de consultas basadas en distancias en las que interviene más de un método de acceso, utilizando técnicas basadas en el join y en la consulta del vecino más próximo.

Una vez estudiado el R*-tree como estructura de datos arbórea 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 más cercano y su extensión a los K pares más cercanos. Empezaremos estableciendo los conceptos métricos necesarios para presentar la consulta en cuestión. Posteriormente, definiremos dicha consulta y propondremos algunas aplicaciones de la misma fundamentalmente en el campo de las bases de datos espaciales. A continuación, se establece la relación que existe entre la consulta del par más cercano y el join espacial con la consulta del vecino más próximo. Por último, se definen las métricas entre pares de MBRs y los teoremas que son la base para poder diseñar algoritmos branch-and-bound eficientes que den solución a la consulta en cuestión.

Capítulo 3

60

3.2 La consulta del par más cercano y su extensión a los K pares más cercanos

Antes de definir la consulta núcleo de esta tesis debemos introducir todos los conceptos métricos necesarios, además de ver las diferencias y similitudes de nuestro problema con el conocido problema del par más cercano de un conjunto de puntos. También, enunciaremos algunos ejemplos de aplicación de la consulta de los pares más cercanos sobre bases de datos espaciales como campo de aplicación más representativo.

3.2.1 Métricas

En general, en problemas de geometría relativos a puntos en el espacio interviene el cálculo implícito o explícito de distancias entre dichos puntos. Por ejemplo, tal y como hemos visto en el capítulo anterior, un problema que se presenta en muchas aplicaciones es el de obtener el vecino más próximo entre un punto y un conjunto de puntos dado. La noción de distancia se utilizará para definir el concepto de espacio Euclídeo k-dimensional. Éste es un caso especial de espacio métrico, que a su vez es un espacio topológico con propiedades especiales. Un espacio topológico es un conjunto y una topología sobre dicho conjunto. Una topología definida sobre un conjunto es una familia de subconjuntos que satisface ciertos axiomas. La noción de topología, en un sentido muy general, establece un entorno formal y preciso para fijar las ideas de cercanía y continuidad.

Definición. Espacio topológico. 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 topológico si satisface los tres axiomas siguientes para todo U, V, S:

TATST

TVUTVTUT

TTPT

SA

∈⇒⊆

∈∩⇒∈∈

∈∅∈

∈U )3(

, )2(

, )1(

En la definición anterior, T es una topología 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 intersección de un número finito de conjuntos abiertos es un conjunto abierto (T2), y que la unión de cualquier número de conjuntos abiertos es un conjunto abierto (T3). Es decir, según (T2) y (T3), T es cerrado bajo un número finito de intersecciones y un número arbitrario de uniones de conjuntos abiertos.

Consulta de los pares más cercanos

61

Definición. Métrica y espacio métrico. Sea P un conjunto. Una métrica sobre P es una función dist : P×P → ℜ (siendo ℜ el conjunto de los números reales) que satisface los siguientes axiomas para todo p, q, s ∈ P:

) ,() ,() ,( )4() ,() ,( )3(

0) ,( )2(0) ,( )1(

qsdistspdistqpdistMpqdistqpdistM

qpqpdistMqpdistM

+≤=

=⇔=≥

La métrica dist se denomina distancia entre dos puntos e induce una topología sobre P denominada topología métrica definida por dist. Al par (P, dist) se le denomina espacio métrico. Si A ⊂ P, al par (A, distA×A) se le llama subespacio métrico 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 simétrica, ya que la distancia entre p y q es independiente del orden de aplicación de la métrica (simetría), es decir, no tiene una orientación. 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 métrica sobre puntos definidos por coordenadas reales (elementos de P) tenemos la Lt-métrica, Lt-distancia o métrica de Minkowski, dt(p, q), que pasamos a definir a continuación.

Definición. Lt-distancia o Métrica de Minkowski. Definimos la Lt-distancia, dt(p, q), entre los puntos p = (p1, p2, ..., pk); pi ∈ ℜ y q = (q1, q2, ..., qk); qi ∈ ℜ en el espacio k-dimensional como:

( ) ∞≤≤

−= ∑

=

tsiqpqpdtk

i

tiit 1 , ,

/1

1

( ) ∞=−=≤≤∞ tsiqpqpd iiki

,max ,1

Para t = 2, tenemos la distancia Euclídea (d2), y para t = 1, tenemos la distancia Manhattan (d1). La aplicabilidad de una distancia está fuertemente condicionada por el tipo de aplicación. 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 Euclídea es la más apropiada.

Una propiedad de Lt-distancia (propiedad de la distancia en una dimensión) dice que el valor de la Lt-distancia para una dimensión dada (1≤i≤k) es siempre menor o igual que el valor total de Lt-distancia para todas las dimensiones (k)

( ) ( ) ∞≤≤≤≤≤−= tykisiqpdqpiqpd tiit 1 1 , , , ,

Capítulo 3

62

Los Espacios Euclídeos son importantes ejemplos de espacios métricos. Como caso especial, vamos a considerar el espacio Euclídeo k-dimensional (k es un número entero positivo), que consiste en todas las tuplas k-dimensionales o puntos p = (p1, p2, ..., pk) de números reales que se pueden formar tal que pi ∈ ℜ , 1≤i≤k. La métrica Euclídea está descrita por la función de distancia Euclídea, basada en coordenadas reales.

Definición. Espacio Euclídeo k-dimensional, E(k). El espacio Euclídeo k-dimensional (k es un número entero positivo) es el espacio métrico definido por, E(k) = {p = (p1, p2, ..., pk); pi ∈ ℜ , 1≤i≤k} con la topología determinada por la métrica Euclídea (distancia Euclídea).

∑=

−=k

iii qpqpd

1

2) ,(

Es decir, el espacio Euclídeo k-dimensional es el espacio k-dimensional de datos (D(k)) dotado con la distancia Euclídea, y que denotamos como E(k).

Por ejemplo, si tenemos dos puntos p y q en E(2), con coordenadas p = (p1, p2) y q = (q1, q2), obtenemos la siguiente expresión para la distancia Euclídea:

( ) 222

211 , qpqpqpd −+−=

3.2.2 El par más cercano de un conjunto de puntos

El problema del par más cercano es uno de los clásicos en geometría computacional y consiste en encontrar los dos puntos más cercanos entre sí de un conjunto de puntos dado. Para encontrar la distancia mínima entre dos puntos p y q perteneciendo a un conjunto de puntos P, parecería 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 podría significar un tiempo de ejecución proporcional a N2. No obstante, como veremos más adelante, es posible utilizar una ordenación para examinar sólo aproximadamente N*logN distancias entre puntos, en el peor de los casos.

Definición. Par más cercano de un conjunto de puntos. El par más cercano de un conjunto de puntos P en el espacio Euclídeo k-dimensional, es un par (p, q) de puntos distintos p, q ∈ P tal que la distancia entre p y q es mínima, siendo p = (p1, p2, ..., pk) y q = (q1, q2, ..., qk).

Para resolver el problema del par más cercano de un conjunto de N puntos en E(2), en [ShH75] se presenta un algoritmo con tiempo de ejecución O(N*logN), y en [BeS76] aparece un algoritmo para el caso general de dimensión k ≥ 2.

El algoritmo básico [ShH75] utilizado para resolver este problema está basado en una estrategia de divide y vencerás. La idea es ordenar los puntos según una coordenada, por


63

ejemplo la coordenada X (dimensión 1), y utilizar después esa ordenación para dividir los puntos en dos mitades según una línea divisoria. El par más cercano del conjunto está en una de las dos mitades o está formado por un elemento de cada mitad. Cuando el par más cercano está en una de las dos mitades se puede encontrar fácilmente procediendo recursivamente, pero el problema surge cuando queremos comprobar eficazmente todos los pares cuyos elementos están uno a cada lado de la línea divisoria.

Puesto que la única información que se busca es encontrar el par más cercano de un conjunto de puntos, sólo se necesita examinar los puntos que están dentro de la distancia min de la línea divisoria, siendo min la menor de las distancias entre los pares más cercanos encontrados hasta el momento en las dos mitades. No obstante, esta observación no es suficiente en el peor caso, ya que pueden haber muchos pares de puntos muy cercanos a la línea divisoria. Para tratar tales situaciones, parece necesario ordenar los puntos según la coordenada Y (dimensión 2).

Después se puede limitar el número de cálculos 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 línea divisoria. Para cada punto que verifique dicha condición, se calcula la distancia entre él y otro punto cualquiera situado también dentro de la franja cuya coordenada Y sea menor que la coordenada Y del punto en cuestión, 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 sólo unos pocos puntos.

Desde el punto de vista de geometría computacional, el cálculo del par más cercano descrito anteriormente es considerado estático debido a que una vez encontrado el par más cercano no se realiza ninguna actualización del conjunto de puntos (entendiéndose como actualización, cualquier inserción o eliminación de uno o más puntos del conjunto), para seguir obteniendo el par más cercano después de una inserción o borrado de uno o más puntos en dicho conjunto.

Existen otras formas de obtener el par más cercano de forma dinámica, siendo éste también un problema muy estudiado desde el punto de vista de geometría computacional. Este problema consiste, en dado un conjunto de N puntos en el espacio k-dimensional y una Lt-distancia, encontrar el par más cercano después 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 más cercano de dicho conjunto de puntos ante inserciones o eliminaciones. Para resolver este problema existen muchos trabajos, siendo los más representativos [ScS92, SSS92, Bes95].

El problema que nosotros planteamos para su resolución no es abordado estrictamente desde una perspectiva de geometría computacional, pero sí se puede considerar una extensión al descrito en [ShH75], ya que está enfocado desde un punto de vista estático.

Capítulo 3

64

3.2.3 Definición de la consulta del par más cercano y su extensión a los K pares más cercanos

En este epígrafe vamos a definir las consultas de los pares más 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 métrica (distancia Euclídea).

Definición. Consulta del Par más Cercano. CPC. Dados dos conjuntos no vacíos P y Q (P ≠ ∅ y Q ≠ ∅), la consulta del par más cercano se define como el siguiente conjunto:

CPC(P, Q) = {(O, O’) ⊆ P×Q: ∀(Oi, Oj’) ⊆ P×Q – {(O, O’)}, d(O, O’) ≤ d(Oi, Oj’)}

En nuestro caso, todos los objetos de P y Q tienen asociado un conjunto de atributos espaciales AP y AQ tal que los objetos espaciales O.AP y O.AQ pertenecen a E(k), y d es la distancia Euclídea.

Es decir, la Consulta del Par más Cercano (CPC) de dos conjuntos de objetos espaciales P y Q nos devuelve un par que tiene la distancia Euclídea más pequeña entre todos los posibles pares de objetos espaciales que se pueden formar escogiendo un objeto de P y otro objeto de Q.

La extensión de esta consulta para el caso general de obtener los K pares más cercanos se muestra a continuación.

Definición. Consulta de los K Pares más Cercanos. K-CPC. Dados dos conjuntos no vacíos P y Q (P ≠ ∅ y Q ≠ ∅), la consulta de los K pares más cercanos se define como un conjunto conteniendo subconjuntos de P×Q, cada uno de ellos con K (1≤K≤|P|·|Q|) pares de objetos distintos y ordenados en ranking según su distancia. Es decir, como el siguiente conjunto:

K-CPC(P, Q, K) = {{(O1, O1’), (O2, O2’), ..., (OK, OK’)} ⊆ P×Q; (Oi, Oi’) ≠ (Oj, Oj’) ∀i ≠ j:

∀(Oi, Oj’) ⊆ P×Q – {(O1, O1’), (O2, O2’), ..., (OK, OK’)}, Oi ∈ P, Oj’ ∈ Q,

d(O1, O1’) ≤ d(O2, O2’) ≤ ... ≤ d(OK, OK’) ≤ d(Oi, Oj’)}

En este caso, al igual que para CPC, todos los objetos de P y Q tienen asociado un conjunto de atributos espaciales AP y AQ tal que los objetos espaciales O.AP y O.AQ pertenecen a E(k), y d es la distancia Euclídea.

Es decir, la Consulta del los K Pares más 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 según su distancia Euclídea, y que tienen las K distancias más pequeñas 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 número de objetos


65

de P y Q, respectivamente. Es decir, K debe ser menor que el número 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 más próximo en el sentido de que las métricas y heurísticas de poda para algoritmos branch-and-bound son similares para reducir el espacio de búsqueda 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 Euclídea, 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 más de un par con la misma distancia mínima y dependiendo del algoritmo que se aplique dé una solución u otra. Por ejemplo, supongamos que tenemos como pares de puntos candidatos en E(2) a ser el par más cercano (p1, q7), (p5, q6) y (p2, q9), 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 más cercano dependiendo del algoritmo que se aplique para determinarlo. Esta situación para el caso de K-CPC es muy similar, supongamos que tenemos los mismos conjuntos de datos (P y Q), y que nuevamente están como pares candidatos a ser los 3 pares más cercanos (K = 3) (p1, q7), (p5, q6) y (p2, q9) 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 más cercanos {(p1, q7), (p5, q6), (p2, q9)}, {(p1, q7), (p2, q9), (p5, q6)}, {(p5, q6), (p1, q7), (p2, q9)}, {(p5, q6), (p2, q9), (p1, q7)}, {(p2, q9), (p1, q7), (p5, q6)} o {(p2, q9), (p5, q6), (p1, q7)}, según el algoritmo que se aplique. Por lo tanto, el objetivo principal que se persigue es obtener una instancia de todos los posibles subconjuntos solución que se pueden generar para obtener CPC o K-CPC, y no todos ellos, aunque generar todos los posibles subconjuntos de K pares más cercanos no es tarea difícil [Ast00].

Por ejemplo, la situación que se puede plantear para K-CPC cuando no existe un único subconjunto solución es que para el mismo valor de distancia del par más lejano de los K pares más cercanos exista un número 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 más lejano de los K pares más cercanos). Entonces los i pares con ese mismo valor de distancia habrá que considerarlos como elementos del resultado final, devolviéndolos en una estructura de datos adicional. Con este caso particular, queremos decir que los algoritmos que procesan las consultas de los pares más cercanos (CPC y K-CPC) devolverán el resultado en dos estructuras de datos: (1) un conjunto principal no vacío formado por el par más cercano (CPC) o por los K pares más cercanos (K-CPC), y (2) un conjunto adicional, vacío 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 = {p1, p2, p3} (Figura 3.1.a) y Q = {q1, q2, q3} (Figura 3.1.b). Los puntos del conjunto P los etiquetamos con cruces y a los puntos de Q con asteriscos. El mínimo rectángulo que envuelve (MBR) cada conjunto está representado con un MBR en líneas discontinuas, y rotulamos con un MBR en líneas continuas a una parte del plano. Para poder distinguir de forma visual los pares más cercanos de estos conjuntos, en la Figura 3.1.c aparecen los dos conjuntos de puntos juntos. Es evidente que el par más cercano

Capítulo 3

66

de puntos (CPC) es (p3, q1) y los 2 pares más cercanos (2-CPC) son {(p3, q1), (p2, q2)}. 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 más cercanos (3-CPC) son {(p3, q1), (p2, q2), (p3, q2)}, y los 4 pares más cercanos (4-CPC) son {(p3, q1), (p2, q2), (p3, q2), (p3, q3)}, y así sucesivamente. Es interesante notar que los MBRs de los dos conjuntos de puntos P y Q están parcialmente solapados. Evidentemente, cuanto más grande es la porción de solape entre los dos MBRs de los conjuntos de puntos, mayor es la probabilidad de que aparezcan más pares con distancias pequeñas. Un algoritmo que responda a la consulta de los K pares más 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á más recursos para poder llevar a cabo la consulta.

+ p1

+ p3 + p2

(a)

* q1

* q3

* q2

(b)

+ p1

+ p3 + p2 * q1

* q3

* q2

(c)

P P

Q Q

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

3.2.4 Ejemplos de aplicación de las consultas de los pares más cercanos sobre datos espaciales

Existen muchos tipos de consultas en la vida real para los que es necesario la obtención del par más cercano o de los K pares más cercanos. Un ejemplo representativo de este tipo de consulta utilizando información espacial, podría ser el siguiente:

• Información espacial: P = conjunto de objetos espaciales que representan las ubicaciones de hoteles de una determinada región (provincia de Almería). Q = Conjunto de objetos espaciales que representan las posiciones geográficas referentes a puntos de interés turístico dentro de la misma región.

• Consulta: Determinar el conjunto de los K pares de objetos (hotel, centro turístico) más próximos entre sí. Es decir, encontrar aquellos pares de objetos que tienen los K valores de distancias más pequeños, para que los turistas acomodados en un hotel puedan visitar fácilmente un centro turístico 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 turísticos, a decidir la ruta a seguir sobre determinados hoteles de forma que por tener cerca un lugar de interés turístico no molesten demasiado a sus clientes a la hora de realizar los desplazamientos.


67

En este ejemplo, gestionamos información espacial que puede estar integrada en un sistema de base de datos espacial. Según [Güt94] se define un sistema de base de datos espacial (SBDE) como aquél que verifica las siguientes propiedades:

1. Es un sistema de base de datos. Según [ElN97], SBD está formado básicamente por la base de datos, el diccionario de datos, el sistema de gestión 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 implementación, suministrando métodos de indexación 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, líneas, 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 aún que soporte tipos de datos definidos por el usuario. La mayoría de los sistemas de gestión 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 [Güt89], PROBE [OrM88], GEO-KERNEL [ScW86] y GEO++ [ViO92] son los más conocidos. Los modelos de datos basados en objetos también 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 extensión espacial de un SGBD de diferente naturaleza (relacional, orientado a objetos, etc.). Por ello, para nuestro ejemplo, suponemos que dicha extensión 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 algún tipo de dato espacial (punto, línea, región, polígono, etc.). En nuestro esquema ejemplo, al igual que en [SaA95], vamos a considerar relaciones que contienen información (atributos) espacial expresada por tipos de datos espaciales como: POINT (puntos), LINE_SEGMENT (segmentos de línea), REGION (regiones) POLYGON (polígonos), BOX (rectángulos), etc. En particular, vamos a considerar los puntos (POINT) que representan la localización espacial de hoteles y lugares de interés turístico de la provincia de Almería.

Para la definición 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 serían las siguientes:

CREATE TABLE Hoteles ( hotel_id NUMBER,

Capítulo 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 típico sobre el esquema espacial anterior para la consulta de los pares más cercanos podría ser el siguiente: encontrar el nombre, dirección y teléfono de los 10 hoteles más cercanos a cualquier lugar de interés turístico, devolviendo el nombre y la dirección de los lugares de interés turístico. Además, el resultado debe estar ordenado ascendentemente en base a su distancia.

Para expresar esta consulta necesitamos hacer uso de la cláusula STOP AFTER en un SQL extendido que procese información espacial. En [CaK97] se hace una extensión de SQL con el objetivo de limitar la cardinalidad del resultado de una consulta para un número de tuplas definido por el usuario, para lo que incluye la cláusula STOP AFTER como un sufijo opcional. De igual forma, suponemos que el tipo de dato espacial POINT tiene asociada la función distance que devuelve la distancia entre dos puntos en E(2). La sentencia SQL para nuestro ejemplo sería 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 más cercanos muy parecida a la anterior y sin utilizar la cláusula STOP AFTER sería por ejemplo: encontrar el nombre, dirección y teléfono de todos los hoteles que están a menos de 5 kilómetros de cualquier lugar turístico, devolviendo el nombre y la dirección de los lugares turísticos. Además, 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


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 más cercanos y generalizar el enunciado diciendo: determinar el nombre, dirección y teléfono de los K hoteles más cercanos a cualquier lugar de interés turístico, devolviendo de este último el nombre y la dirección estando a una distancia menor de D kilómetros. Además, el resultado debe estar ordenado ascendentemente en base a su distancia.

Después de haber visto el ejemplo de los hoteles y los lugares turísticos, podemos considerar otros tales como:

• Información espacial: P = Conjunto de objetos espaciales que representan las localizaciones geográficas de centralitas de conexión de una compañía telefónica para una ciudad determinada (Almería). Q = Conjunto de objetos espaciales que representan las posiciones geográficas de edificios en construcción (potenciales conexiones a líneas telefónicas) dentro de la misma ciudad.

• Consulta: Determinar el conjunto de los K pares de objetos (centralita de conexión, edificio en construcción) más cercanos entre sí. Es decir, la ubicación de las centralitas más cercanas a cualquier edificio en construcción.

• Utilidad: La utilidad de esta consulta es ayudar a una empresa que se dedica a la instalación de líneas telefónicas, para indicarle cuál es la centralita de conexión telefónica más cercana a cualquier edificio en construcción, ahorrando con ello en el cableado necesario para la conexión telefónica. Aclaración: Para esta aplicación es necesario utilizar la distancia Manhattan en lugar de distancia Euclídea, ya que no tiene sentido atravesar los edificios para instalar el cableado de una línea.

• Información espacial: P = Conjunto de objetos espaciales que representan la posición geográfica de los pozos de agua en una determinada región (provincia de Granada). Q = Conjunto de objetos espaciales que representan las ubicaciones geográficas de los núcleos de población de otra región (provincia Almería).

• Consulta: Determinar el conjunto de los K pares de objetos (pozo, núcleo de población) más cercanos entre sí.

• Utilidad: El objetivo de esta consulta es obtener el pozo de agua que se puede encontrar en la provincia de Granada más cercano a cualquier núcleo de población de la provincia de Almería en orden ascendente de distancia. La utilidad radica en tener la posibilidad de realizar un trasvase de agua con el menor coste posible. Aclaración. 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 información espacial y a los cuales se le puede aplicar las consultas de los pares más cercanos son: almacenes y tiendas, taxis y paradas de taxis, ciudades y autovías, 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.

Capítulo 3

70

3.3 Las consultas join y el vecino más próximo, como base para las consultas de los pares más cercanos

Como hemos comentado anteriormente, la consulta del par más cercano o de los K pares más 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 más próximo en el sentido de que métricas basadas en distancias y heurísticas de poda aplicadas en algoritmos branch-and-bound son similares, con el objetivo de reducir el espacio de búsqueda 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 más 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 evaluación del predicado Θ(p, q) es cierta, es decir,

JE(P, Q, Θ) = {(p, q) ∈ P×Q : Θ(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 y como hemos visto para el join espacial en el capítulo 2, pero como las estructuras de datos base de esta tesis son los R*-trees, sólo nos vamos a preocupar de los algoritmos (recursivos e iterativos) sobre métodos de acceso multidimensionales arbóreos 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 combinación 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 concatenación de los dos R*-trees se organizan en una cola de prioridad (implementada como un montículo) cuya clave de ordenación es la mínima distancia entre los elementos que forman el par. La segunda alternativa está basada en la idea propuesta en [HJR97a], donde se


71

plantea un algoritmo iterativo que concatena ambos R*-trees según una política 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 más cercanos (CPC y K-CPC), en el sentido de utilizar la estructura de los algoritmos sobre métodos de acceso multidimensionales arbóreos para generar todos los posibles pares de objetos candidatos al resultado final.

3.3.2 La consulta del par más cercano utilizando R*-trees

En [RKV95, HAK00] se define la consulta de vecino más próximo de la siguiente forma: dado un punto p = (p1, p2, ..., pk) en E(k), encontrar el objeto O perteneciente a un conjunto de objetos P más próximo a p.

CVP(p, P) = {O ∈ P: ∀O’ ⊆ P – {O}, d(p, O) ≤ d(p, O’)}

La extensión de esta consulta para obtener los K vecinos más próximos es sencilla y consiste en dado un punto p en E(k), encontrar los K objetos distintos {O1, O2, ..., OK} pertenecientes a un conjunto de objetos P más próximos a p. Para ello, definimos una colección de K objetos ordenados y distintos,

K-CVP(p, P, K) = {{O1, O2, ..., OK} ⊆ P; Oi ≠ Oj ∀i ≠ j:

∀O’ ⊆ P – {O1, O2, ..., OK}, d(p, O1) ≤ d(p, O2) ≤ ... ≤ d(p, OK) ≤ d(p, O’)}

En [RKV95] se propone un algoritmo branch-and-bound recursivo para encontrar el vecino más próximo sobre R-trees (CVP_Recursivo, algoritmo recursivo visto en el capítulo 2), que a su vez es una extensión 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 = (p1, p2, ..., pk) y un MBR R definido por dos puntos (s, t) en E(k) [RKV95, PaM98].

Definición. Mínima distancia de un punto a un objeto en E(k). La distancia mínima de un punto p a un objeto o, representada por ||(p, o)||, en E(k), se define según [RKV95] como:

( ) oxxxxxpop k

k

iii ∈=∀

−= ∑=

,...,,,min) ,( 211

2

De forma equivalente podemos definir esta misma distancia en función de las caras del objeto en E(k) (u objeto multidimensional), basándonos 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 función de su frontera, la cual está formada por caras. Una cara de un “k-polytope” convexo es otro “polytope” convexo de una dimensión menor (“(k – 1)-polytope”); una k-cara denota una cara k-

Capítulo 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 vértices. Por ejemplo, para un 3-polytope, facets son polígonos planos, mientras que subfacets y aristas coinciden. Además, la unión de un número 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-líneas y puntos sería considerar poliedros de dimensión 2, 1 y 0.

Definición. Mínima distancia de un punto a un objeto en E(k) en función de las caras del objeto. La distancia mínima de un punto p a un objeto o caracterizado por su conjunto de caras, representada por ||(p, o)||, en E(k), se define como:

{ }{ }) ,(minmin) ,( )( ffpoFf ppdopf ∈∈=

donde F(o) es el conjunto de caras que forman el objeto o en E(k). Además, f es una instancia de esas caras en F(o), y d es la función que calcula la distancia entre dos puntos p y pf, definida en E(k), donde pf es un punto en alguna de las caras de o.

La primera métrica entre un punto p y un MBR R en E(k), se denomina MinDist(p, R). Esta métrica, de forma intuitiva, representa el mínimo valor de distancia desde un punto a un MBR definido por dos puntos.

Definición. MinDist(p, R). Dado un punto p = (p1, p2, ..., pk) y un MBR R = (s, t), donde s = (s1, s2, ..., sk) y t = (t1, t2, ..., tk) tal que si ≤ ti, ∀1≤i≤k, en E(k), se define MinDist(p, R) de la siguiente manera:

∑=

−=k

iii rpRpMinDist

1

2) ,(

donde,

>

<

=casosotroslosenp

tpsit

spsis

r

i

iii

iii

i

, ,

,

Debemos destacar que MinDist(p, R) requiere un orden lineal para su cálculo O(k), dependiendo del número de dimensiones que se consideren en E(k).

Teorema 3.1. Dado un punto p = (p1, p2, ..., pk) y el MBR R que envuelve a un conjunto de objetos O = {oi, 1≤i≤N} en E(k), entonces para todo oi perteneciente a O se verifica que:

) ,() ,( iopRpMinDist ≤

Demostración: [RKV95]. £

La segunda métrica entre un punto p y un MBR R en E(k), es la denominada MinMaxDist(p, R). Esta métrica, de forma intuitiva, representa el mínimo valor de todas las máximas distancias entre un punto y un MBR sobre cada una de las k dimensiones. Es decir, ésta es la máxima distancia entre el punto y la cara más próxima del MBR, donde F(R) es el


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 métrica. Por ello, MinMaxDist(p, R) nos proporciona una cota superior para el vecino más próximo de un punto.

( ) ( ) ( )RFxxxxxpRpMinMaxDist k

k

iii ∈=∀

−= ∑=

,...,,,maxmin, 211

2

Definición. MinMaxDist(p, R). Dado un punto p = (p1, p2, ..., pk) y un MBR R = (s, t), donde s = (s1, s2, ..., sk) y t = (t1, t2, ..., tk) tal que si ≤ ti, ∀1≤i≤k, en E(k), definimos MinMaxDist(p, R) de la siguiente manera:

−+−= ∑≠=

≤≤

k

jiiiijj

kjrMprmpRpMinMaxDist

,1

22

1min) ,(

donde, ( )

+≤

=casosotroslosent

tspsis

rm

j

jjjj

j

,2

, y,

( )

+

≥=

casosotroslosent

tspsis

rM

i

iiii

i

,2

,

El algoritmo para el cálculo 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 = (p1, p2, ..., pk) y el MBR R que envuelve a un conjunto de objetos O = {oi, 1≤i≤N} en E(k), existe un oi ∈ O tal que:

) ,() ,( RpMinMaxDistop i ≤

Demostración. [RKV95]. £

La última métrica entre un punto p y un MBR R propuesta en [PaM98] es la denominada MaxDist(p, R) y representa la máxima distancia desde el punto p hasta un MBR R delimitado por dos puntos en E(k).

( ) ( ) ( )RFxxxxxpRpMaxDist k

k

iii ∈=∀

−= ∑=

,...,,,maxmax, 211

2

Definición. MaxDist(p, R). Dado un punto p = (p1, p2, ..., pk) y un MBR R = (s, t), donde s = (s1, s2, ..., sk) y t = (t1, t2, ..., tk) tal que si ≤ ti, ∀1≤i≤k, en E(k), definimos MaxDist(p, R) de la siguiente manera:

∑=

−=k

iii rpRpMaxDist

1

2) ,(

Capítulo 3

74

donde, ( )

+

≤=

casosotroslosens

tspsit

r

i

iiii

i

,2

,

Teorema 3.3. Dado un punto p = (p1, p2, ..., pk) y el MBR R que envuelve a un conjunto de objetos O = {oi, 1≤i≤N} en E(k), se verifica para todo oi en O:

) ,() ,( RpMaxDistop i ≤

Demostración: [PaM98]. £

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

p

R1

R2

MinDist

MinMaxDist

MaxDist

Figura 3.2 MinDist, MinMaxDist y MaxDist entre un punto p y los MBRs R1 y R2 en E(2).

Las métricas, MinDist(p, R) y MinMaxDist(p, R) junto con los teoremas 3.1 y 3.2 se utilizan en tres reglas básicas que se aplican para realizar la poda del R*-tree cuando se recorre éste desde la raíz hasta las hojas según un algoritmo branch-and-bound para encontrar el vecino más próximo [RKV95]. Las heurísticas 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 más próximo 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 Euclídea 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 Euclídea procesada hasta el momento para el vecino más próximo o los K vecinos más próximos, entonces descartamos todos los MBRs Ri con distancia MinDist(p, Ri) mayor que T, porque ellos no pueden envolver un vecino más próximo o los K vecinos más próximos 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 Ri


75

candidatos según MinDist(p, Ri), porque se eliminan ramas candidatas de forma más rápida conforme el algoritmo progresa.

Para el caso genérico del los K vecinos más próximos (K-CVP), además de aplicar la regla (3) y utilizar un montículo máximo adicional con los K vecinos más próximos procesados hasta el momento, situando en la raíz 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 ramificación 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 métrica MinMaxDist(p, R).

En la Figura 3.3 se puede observar los MBRs aceptados (R3 y R5, en líneas continuas) y descartados (R1, R2, R4 y R6, en líneas de puntos) aplicando las estrategias de poda basadas en MinMaxDist(p, R) para obtener el vecino más próximo. Realmente, aplicamos la heurística (1), ya que el mínimo valor para MinMaxDist(p, R) es MinMaxDist(p, R3) = T, y después debemos descartar todos los MBRs que verifiquen la siguiente condición: MinDist(p, Ri) > MinMaxDist(p, R3) = T, y en nuestro ejemplo, Ri = R1, R2, R4 y R6.

R1

R2

R3

R4

R5

R6

MinDist MinMaxDist

p

Figura 3.3 Aplicación de la estrategia de poda para encontrar el vecino más próximo.

En resumen, nos vamos a basar en la consulta del vecino más próximo en el sentido de que propondremos unas distancias entre pares de MBRs definidos por dos puntos en E(k), y unas propiedades sobre esas métricas (heurísticas de poda) que nos servirán para diseñar algoritmos branch-and-bound que llevan a cabo un proceso de poda durante el recorrido simultáneo sobre ambos R*-trees, obteniendo el par más cercanos o los K pares más cercanos.

Capítulo 3

76

3.4 Métricas entre pares de MBRs para el procesamiento de las consultas de los pares más cercanos

Debido a que los diferentes algoritmos branch-and-bound que se propondrán para determinar las consultas de los pares más cercanos actúan sobre pares de MBRs procedentes de la combinación de dos R*-trees, debemos definir métricas entre pares de MBRs para aplicarlas como mecanismos de poda en dichos algoritmos. Además, sabemos que un MBR en E(k)

representa el mínimo rectángulo 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 dimensión.

Las métricas más importantes que vamos a definir entre pares de MBRs en E(k), son MinMinDist(R1, R2), MinMaxDist(R1, R2) y MaxMaxDist(R1, R2), cuyo significado es el siguiente:

1. MinMinDist(R1, R2). Representa la mínima distancia que hay entre dos MBRs, R1 y R2.

2. MinMaxDist(R1, R2). Representa la mínima de todas las máximas distancias entre las caras paralelas más próximas de dos MBRs, R1 y R2, para cada una de las dimensiones.

3. MaxMaxDist(R1, R2). Representa la máxima distancia que hay entre dos MBRs, R1 y R2.

La primera métrica que vamos a introducir, MinMinDist(R1, R2), es una extensión de la definición de MinDist(p, R) hecha en [RKV95] entre un punto y un MBR, pero aplicada entre dos MBRs definidos en E(k).

Definición. Mínima distancia entre MBRs, MinimaDistancia(R1, R2). La mínima distancia entre dos MBRs, R1 y R2, definidos en E(k), denotada como MinimaDistancia(R1, R2), es la menor de las distancias entre las caras que los forman y se define como:

( ) ( ){ }{ }21 ,)( ),(21 ,minmin ,22112211

ppdRRanciaMinimaDist fpfpRFfRFf ∈∈∈∈=

donde F(R1) y F(R2) son los conjuntos de caras que forma los MBRs R1 y R2, respectivamente. Además, f es una instancia de las caras que forman dichos conjuntos, y d es la distancia Euclídea entre dos puntos definidos en E(k).

A continuación, damos una definición algorítmica a esta distancia que denominamos MinMinDist.

Definición. MinMinDist(R1, R2). Dados dos MBRs R1 = (s, t) y R2 = (p, q) en E(k), R1 = (s, t), donde s = (s1, s2, ..., sk) y t = (t1, t2, ..., tk) tal que si ≤ ti, ∀1≤i≤k, R2 = (p, q), donde p = (p1, p2, ..., pk) y q = (q1, q2, ..., qk) tal que pi ≤ qi, ∀1≤i≤k, definimos MinMinDist(R1, R2) de la siguiente manera:

∑=

=k

iiyRRMinMinDist

1

221 ) ,(


77

donde,

>−

<−

=

casosotroslosen

tpsitp

sqsiqs

y iiii

iiii

i

,0

,

,

Debemos destacar que el cálculo de MinMinDist(R1, R2) requiere sólo un tiempo lineal O(k), que depende del número de dimensiones.

La Figura 3.4 ilustra la métrica MinMinDist(Ri, Rj) definida entre dos MBRs en E(2).

R1

R2

R3

R4

Figura 3.4 MinMinDist(Ri, Rj) entre dos MBRs en E(2).

Proposición 3.1. Dados dos MBRs R1 = (s, t) y R2 = (p, q) en E(k), entonces se cumple que:

MinimaDistancia(R1, R2) = MinMinDist(R1, R2)

Demostración:

Para demostrar esta igualdad debemos probar que MinMinDist(R1, R2) es la menor distancia Euclídea que existe desde cualquier punto del perímetro de R1 a cualquier otro punto del perímetro de R2. Para ello, debemos estudiar el comportamiento de MinMinDist(R1, R2) en cada una de las dimensiones 1≤i≤k, comprobando si R1 y R2 se solapan o no en cada dimensión.

La distancia Euclídea desde cualquier punto del perímetro de R1 a cualquier otro punto del perímetro de R2, viene dada por la siguiente expresión:

iiiiiiii

k

iii qbptas:ba baRRd ≤≤≤≤∀−= ∑

=

y ,,) ,(1

221

y nuestro objetivo es encontrar la expresión que minimiza d(R1, R2), es decir min{d(R1, R2)}.

También, debemos tener en cuenta que dos MBRs se solapan si, y sólo si comparten al menos un punto en alguna de sus dimensiones. La instancia más simple de un MBR ocurre en una dimensión (k=1), donde los MBRs son intervalos. Debido a que un MBR en E(k), es el

Capítulo 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 R1 = (s, t) y R2 = (p, q) en E(k), se solapan si, y sólo si existe una dimensión i tal que: si ≤ qi y pi ≤ ti. Considerando la negación de la condición anterior, dos MBRs R1 = (s, t) y R2 = (p, q) en E(k), no se solapan si, y sólo si se verifica la siguiente condición: si > qi ó pi > ti, ∀ 1 ≤ i ≤ k.

Caso 1. R1 y R2 se solapan en la dimensión i.

La condición de solape es, que existe al menos una dimensión i tal que si ≤ qi y pi ≤ ti. Además, sabemos que cualquier punto del perímetro de R1 verifica que si ≤ ai ≤ ti, y cualquier punto del perímetro de R2, pi ≤ bi ≤ qi. De todo ello obtenemos las siguientes condiciones: ((si ≤ ai ≤ qi) y (pi ≤ ai ≤ ti)) o ((si ≤ ai ≤ qi) y (pi ≤ ai ≤ ti)). Por tanto, existe al menos un par (ai, bi) en el conjunto intersección tal que ai = bi, entonces |ai – bi| = 0. Obteniéndose que, para la distancia Euclídea desde cualquier punto del perímetro de R1 a cualquier otro punto del perímetro de R2, cuando los MBRs se solapan en una determinada dimensión i, entonces dicha dimensión no interviene en el cálculo de la distancia (valor 0). Por tanto, MinimaDistancia(R1, R2) es 0 para esa dimensión i, igual que ocurre para MinMinDist(R1, R2).

Caso 2. R1 y R2 no se solapan en la dimensión i.

La condición de no solape (disjuntos) es, si > qi ó pi > ti, ∀ 1 ≤ i ≤ k. Además, sabemos que cualquier punto del perímetro de R1 verifica que si ≤ ai ≤ ti, y cualquier punto del perímetro de R2, pi ≤ bi ≤ qi. De todo ello obtenemos las siguientes condiciones: ((qi < si ≤ ai) o (ai ≤ ti < pi)) y ((bi ≤ qi < si) o (ti < pi ≤ bi)). Por tanto, tenemos que ∀ 1 ≤ i ≤ k: ai > bi o bi > ai, entonces |ai – bi| > 0. Obteniéndose que, para la distancia Euclídea desde cualquier punto del perímetro de R1 a cualquier otro punto del perímetro de R2, cuando los MBRs no se solapan en una determinada dimensión i, dicha dimensión sí interviene en el cálculo de la distancia. Igual que ocurre para MinMinDist(R1, R2). El valor de min{d(R1, R2)} es min{|ai – bi|} para dimensión i.

• Si si > qi, entonces min{d(R1, R2)} = min{|ai – bi|} = |si – qi|, igual que ocurre para MinMinDist(R1, R2).

• Si pi > ti, entonces min{d(R1, R2)} = min{|ai – bi|} = |ti – pi|, igual que ocurre para MinMinDist(R1, R2).

Por tanto, de los resultados anteriores tenemos que min{d(R1, R2)} = MinMinDist(R1, R2). £

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 generalización de la distancia entre los elementos (MBRs o puntos) que pueden constituir un R*-tree.


79

Lema 3.1. Propiedad de MinMinDist. Dados dos MBRs R1 = (s, t) y R2 = (p, q) en E(k),

1. Si si = ti para R1 = (s, t) y pi = qi para R2 = (p, q), entonces los dos MBRs degeneran en dos puntos s = (s1, s2, ..., sk) y p = (p1, p2, ..., pk), y por tanto MinMinDist(R1, R2) es igual a la distancia Euclídea entre los puntos s y p.

∑=

−=k

iii pspsd

1

2) ,(

2. Si si = ti para R1 = (s, t), entonces este MBR degenera en un punto s = (s1, s2, ..., sk), y por tanto MinMinDist(R1, R2) = MinDist(s, R2) [RKV95].

3. Si pi = qi para R2 = (p, q), entonces este MBR degenera en un punto p = (p1, p2, ..., pk), y por tanto MinMinDist(R1, R2) = MinDist(p, R1) [RKV95].

Demostración:

Inmediata, considerando la definición de MinMinDist entre dos MBRs, la distancia Euclídea 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 dimensión y establece que el valor de MinMinDist entre dos MBRs en una dimensión 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 dimensión. Dados dos MBRs R1 = (s, t) y R2 = (p, q) en E(k), entonces el valor de MinMinDist(R1, R2) en una dimensión determinada i (1≤i≤k) es siempre menor o igual que MinMinDist(R1, R2). Es decir,

( ) ( ) kiRRMinMinDistiRRMinMinDist ≤≤∀≤ 1 ,,,, 2121

donde iyiRRMinMinDist =), ,( 21 tal que

>−

<−

=

casosotroslosen

tpsitp

sqsiqs

y iiii

iiii

i

,0

,

,

Demostración:

Inmediata, considerando la definición de MinMinDist entre dos MBRs y la propiedad de la distancia en una dimensión. £

La Figura 3.5 ilustra esta propiedad de MinMinDist.

Capítulo 3

80

MinMinDist(R1, R2, i)

R1

R1

R2

MinMinDist(R1, R2)

Figura 3.5 Propiedad de MinMinDist en una dimensión 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 NP y NQ (con MBRs MP0 y MQ0) de dos R*-trees RP y RQ, respectivamente. Estos dos nodos internos están envolviendo dos conjuntos de MBRs {MP1, MP2, …, MPA} y {MQ1, MQ2, …, MQB}. Entonces

MinMinDist(MPi, MQj) ≥ MinMinDist(MP0, MQ0): ∀1≤i≤A y ∀1≤j≤B

MinMinDist(MP0, MQj) ≥ MinMinDist(MP0, MQ0): ∀1≤j≤B

MinMinDist(MPi, MQ0) ≥ MinMinDist(MP0, MQ0): ∀1≤i≤A

Demostración:

Inmediata, considerando la definición de MinMinDist entre dos MBRs y la propiedad de cubrimiento de MBRs en R*-trees. £

Esta propiedad nos indica que la mínima distancia entre dos MBRs almacenados en dos nodos internos NP y NQ (con MBRs MP0 y MQ0) es siempre menor o igual que la mínima distancia entre uno de los MBRs cubiertos por MP0 y uno de los MBRs cubiertos por MQ0. La Figura 3.6 ilustra esta propiedad de MinMinDist para A = B = 3.

MP0

MQ0

MinMinDist(MP2, MQ2)

MP1

MP3 MP2

MQ3

MQ1

MQ2

MinMinDist(MP0, MQ0)

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].


81

Lema 3.4. Propiedad de las caras de un MBR en un R*-tree. Cada cara (segmento de línea 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 algún objeto de la base de datos.

Demostración:

Para demostrar este lema vamos a aplicar inducción 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 están almacenados los MBRs que envuelven a los objetos). Suponemos por contradicción, que una cara del MBR de nivel 0 no comparte ningún punto de algún objeto de la base de datos. Entonces, por definición de MBR, existiría un MBR más pequeño cuyas caras sí comparten algún punto de dicho objeto, lo cual contradice la propia definición de MBR a nivel de hojas (L = 0).

Suponemos que la condición 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 definición de R*-tree que organiza MBRs como una estructura de datos arbórea 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 algún objeto de la base de datos. £

La Figura 3.7 muestra que cada cara del MBR en el nivel, L = i + 1 (línea discontinua) está compartiendo al menos un punto de algún 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.

Capítulo 3

82

Definición. Mínima distancia entre dos objetos en E(k). La distancia mínima entre dos objetos o1 y o2, representada por ||(o1, o2)||, en E(k), se define como:

( ) ( ) 2211211

221 ,...,,y ,...,,,min) ,( oyyyyoxxxxyxoo kk

k

iii ∈=∀∈=∀

−= ∑=

De forma equivalente podemos definir esta misma distancia en función de las caras de los objetos en E(k) de la siguiente forma.

Definición. Mínima distancia entre dos objetos en E(k) en función de las caras de los mismos. La mínima distancia en E(k), entre dos objetos o1 y o2 caracterizados por sus conjuntos de caras, la denotamos por ||(o1, o2)||, y viene dada por la siguiente expresión:

( ){ }{ }21 ,)( ),(21 ,minmin) ,(22112211

ppdoo fpfpoFfoFf ∈∈∈∈=

donde F(o1) es el conjunto de caras que forman el objeto o1 y F(o2) es el conjunto de caras que forman el objeto o2 en E(k). Además, f es una instancia de esas caras en cualquiera de los anteriores conjuntos (F(o1) y F(o2)), y d es la función que determina la distancia Euclídea entre dos puntos p1 y p2 definidos en E(k), donde p1 y p2 es un par de puntos en alguna de las caras de o1 y o2, respectivamente.

Teorema 3.4. Dados dos MBRs R1 y R2 en E(k), definidos como R1 = (s, t) y R2 = (p, q), envolviendo a los conjuntos de objetos en E(k) O1 = {o1i, 1≤i≤N1} y O2 = {o2j, 1≤j≤N2}, respectivamente. Entonces para todo par de objetos (o1i, o2j) perteneciendo a O1 × O2 se verifica que:

) ,() ,( 2121 ji ooRRMinMinDist ≤

Demostración:

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 conclusión que se puede obtener de esta primera métrica es que MinMinDist(R1, R2) determina una cota inferior de la distancia Euclídea de cualquier par de objetos formado por un objeto o1i ∈ O1 incluido en R1 y otro objeto o2j ∈ O2 incluido en R2. Y es de utilidad para evitar la visita de nodos innecesarios en el procesamiento de una consulta para obtener el par más cercano y su extensión para los K pares más cercanos cuando tenemos dos conjuntos de objetos indexados en sendos R*-trees.

La segunda métrica entre dos MBRs (R1 y R2) que vamos a introducir se denomina MinMaxDist(R1, R2), y representa la mínima de todas las máximas distancias entre las caras paralelas más próximas de dos MBRs, R1 y R2, para cada una de las dimensiones. Ésta es una extensión de la definición de MinMaxDist(p, R) hecha en [RKV95] entre un punto y un MBR, pero aplicada entre dos MBRs definidos en E(k).


83

Definición. MinimaMaximaDistancia(R1, R2). El mínimo valor de todas las máximas distancias entre los puntos que forman las caras de dos MBRs, R1 y R2, definidos en E(k), denotado como MinimaMaximaDistancia(R1, R2), se define como:

( ) ( ){ }{ }21 ,)( ),(21 ,maxmin ,22112211

ppdRRamaDistanciMinimaMaxi fpfpRFfRFf ∈∈∈∈=

donde F(R1) y F(R2) son los conjuntos de caras que forma los MBRs R1 y R2, respectivamente. Además, f es una instancia de las caras que forman dichos conjuntos, y d es la distancia Euclídea entre dos puntos p1 y p2, definidos en E(k), donde p1 y p2 es un par de puntos en alguna de las caras de R1 y R2, respectivamente.

La Figura 3.8 ilustra la métrica MinimaMaximaDistancia(Ri, Rj) definida entre dos MBRs.

R1

R2

R3

R4

Figura 3.8 MinimaMaximaDistancia(Ri, Rj) entre dos MBRs en E(2).

Como ejemplo, vamos a estudiar la forma de calcular MinimaMaximaDistancia(R1, R2) 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 línea (MBRs 1-dimensionales).

b4

b3

b2

b1

a4

a3

a2

a1

(t1, t2)

d d

d

d

(s1, s2)

(p1, p2)

(q1, q2)

R1

R2

Figura 3.9 Distancias entre las caras a1 y b1 para calcular MinimaMaximaDistancia(R1, R2).

Capítulo 3

84

Sean a1, a2, a3, a4 y b1, b2, b3 y b4, las cuatro caras (aristas en E(2)) de los MBRs R1 y R2, respectivamente. A nivel de puntos, tenemos la siguiente definición de las caras: a1 = {(s1, s2), (s1, t2)}, a2 = {(s1, s2), (t1, s2)}, a3 = {(t1, t2), (t1, s2)} y a4 = {(t1, t2), (s1, t2)} para el MBR R1, y b1 = {(p1, p2), (p1, q2)}, b2 = {(p1, p2), (q1, p2)}, b3 = {(q1, q2), (q1, p2)} y b4 = {(q1, q2), (p1, q2)} para el MBR R2.

Denotamos como MAXIMADISTANCIA(ai, bi) a la máxima distancia Euclídea d entre los puntos que delimitan las caras ai y bi, siendo 1≤i≤4. Es decir,

( ) ( ){ } ( )2n , , ,max , Een 4i1ppdbaANCIAMAXIMADIST mbpapii inim

≤≤∀= ∈∈

Una vez calculadas todas las máximas posibles distancias entre las caras de los dos MBRs obtenemos la menor de ellas como valor de MinimaMaximaDistancia(R1, R2).

A continuación vamos a exponer el algoritmo para calcular MinimaMaximaDistancia(R1, R2) en E(2).

MinimaMaximaDistancia(R1: MBR, R2: MBR) 01 MINIMAMAXIMADISTANCIA = ∞; 02 A = conjuntoCaras(R1) = {a1, a2, a3, a4}; // Conjunto de 4 (2k) caras del MBR R1 03 B = conjuntoCaras(R2)= {b1, b2, b3, b4}; // Conjunto de 4 (2k) caras del MBR R2 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(pm ∈ ai, pn ∈ bj); 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 dimensión k – 1. A = {a1, a2, ..., a2k} para el MBR R1 y B = {b1, b2, ..., b2k} para el MBR R2, son sus respectivos conjuntos de caras.


85

2. Si cada MBR en E(k) tiene 2k puntos [Oro98], entonces cada cara (ai) de dimensión k – 1 tendrá 2k-1 puntos. Además, cada punto tendrá k coordenadas, p = (p1, p2, ..., pk).

El algoritmo general para calcular MinimaMaximaDistancia(R1, R2) en E(k) es el que se muestra a continuación.

MinimaMaximaDistancia(R1: MBR, R2: MBR) 01 MINIMAMAXIMADISTANCIA = ∞; 02 A = conjuntoCaras(R1) = {a1, a2, ..., a2k}; // Conjunto de 2k caras del MBR R1 03 B = conjuntoCaras(R2) = {b1, b2, ..., b2k}; // Conjunto de 2k caras del MBR R2 04 i = 1; 05 while (i ≤ 2k) do 06 j = 1; 07 while (j ≤ 2k) do 08 MAXIMADISTANCIA = –∞; 09 m = 1; 10 while (m ≤ 2k-1) do 11 n = 1; 12 while (n ≤ 2k-1) do 13 dist = d(pm ∈ ai, pn ∈ bj); 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 = (s1, s2, ..., sk) y t = (t1, t2, ..., tk), si ≤ ti para todo 1≤i≤k), y se realiza combinando los elementos si y ti en sus k – 1 posibles posiciones para obtener los 2k-1 puntos por cara. Además, d es la función que determina la distancia entre dos puntos pm y pn definidos en E(k). El algoritmo anterior tiene orden exponencial O(2k), dependiendo de la dimensionalidad de E(k). Por lo tanto el coste de cálculo para la métrica MinimaMaximaDistancia(R1, R2) es muy elevado, sobre todo cuando la dimensión k≥4.

Debido a que el cálculo de MinimaMaximaDistancia(R1, R2) tiene un coste exponencial vamos a dar una aproximación de ésta que necesite sólo un coste lineal y que denotaremos como MinMaxDist(R1, R2) entre dos MBRs, R1 y R2, definidos en E(k). Esta métrica representa la mínima de todas las máximas distancias entre las caras paralelas más próximas de los dos MBRs para cada una de las k dimensiones.

Capítulo 3

86

Definición. MinMaxDist(R1, R2). El mínimo valor de todas las máximas distancias entre los puntos que forman las caras paralelas más próximas de dos MBRs R1 = (s, t) y R2 = (p, q) en E(k), R1 = (s, t), donde s = (s1, s2, ..., sk) y t = (t1, t2, ..., tk) tal que si ≤ ti, ∀1≤i≤k, R2 = (p, q), donde p = (p1, p2, ..., pk) y q = (q1, q2, ..., qk) tal que pi ≤ qi, ∀1≤i≤k, la denominamos MinMaxDist(R1, R2), y la definimos de la siguiente manera:

+= ∑≠=

≤≤

k

jiiij

kjyxRRMinMaxDist

,1

22

121 min) ,( ; donde

{ }jjjjjjjjj qtptqspsx −−−−= , , , min e { }iiiii ptqsy −−= , max

La fórmula

∑∑=≠=

+−=+k

iijj

k

jiiij yyxyx

1

222

,1

22 , donde { }( )jjjjj ptqsy −−= , max

expresa la máxima distancia entre las caras paralelas más próximas en la dimensión j. Por tanto, MinMaxDist(R1, R2) será el mínimo valor de todas las distancias de dicha fórmula para las k dimensiones.

Para el cálculo de MinMaxDist(R1, R2), la expresión

∑=

k

iiy

1

2

se calcula sólo una vez, devolviendo la distancia entre los vértices más lejanos de dos MBRs (máxima distancia entre vértices), en un tiempo O(k). Después, se calcula xj

2 – yj2 (para todos

los valores de j, 1≤j≤k) en un tiempo también O(k), donde se anula para esa dimensión j la máxima distancia yj, y se sustituye en esa dimensión (j) por el menor valor de distancia entre las caras de los dos MBRs xj (caras más cercanas para los dos MBRs). Por tanto, el cálculo de MinMaxDist(R1, R2) se determina en un tiempo O(k).

Proposición 3.2. Dados dos MBRs R1 = (s, t) y R2 = (p, q) en E(k), la siguiente propiedad es cierta:

) ,() ,( 2121 RRMinMaxDistRRamaDistanciMinimaMaxi ≤

Demostración:

Inmediata, ya que el conjunto de caras procesado por MinimaMaximaDistancia(R1, R2) es siempre mayor que el procesado al calcular MinMaxDist(R1, R2). £

Esta proposición nos dice que MinMaxDist(R1, R2) es una buena aproximación para determinar una cota superior de la distancia del par más cercano, ya que siempre MinMaxDist(R1, R2) ≥ MinimaMaximaDistancia(R1, R2). Es decir, el valor de MinMaxDist(R1, R2) siempre será mayor o igual que la distancia del par más cercano.


87

La principal ventaja de MinMaxDist(R1, R2) sobre MinimaMaximaDistancia(R1, R2) es que su cálculo se realiza en tiempo lineal O(k), mientras que para MinimaMaximaDistancia(R1, R2) se necesita un tiempo exponencial O(2k), haciendo a esta última impracticable cuando tenemos un número de dimensiones grande (k≥4).

En la Figura 3.10 podemos observar el valor de MinimaMaximaDistancia(R1, R2) y las distancias candidatas para obtener MinMaxDist(R1, R2) sobre cada una de las dimensiones en E(2). De esta figura es evidente que MinimaMaximaDistancia(R1, R2) < MinMaxDist(R1, R2). Por ejemplo, si en la dimensión X (k = 1) de R1 el intervalo [s1, t1] fuese más grande, haciendo que s1 sea cada vez menor mientras que t1 sigue fijo, llegaría un momento en que MinimaMaximaDistancia(R1, R2) = MinMaxDist(R1, R2), y después MinimaMaximaDistancia(R1, R2) será siempre el valor determinado previamente con MinMaxDist(R1, R2).

R2

R1

MinimaMaximaDistancia

Candidatas a MinMaxDist

MinMaxDist

Figura 3.10 MinimaMaximaDistancia(R1, R2) y MinMaxDist(R1, R2) entre dos MBRs en E(2).

Teorema 3.5. Dado dos MBRs R1 y R2 en E(k), definidos como R1 = (s, t) y R2 = (p, q) envolviendo a los conjuntos de objetos en E(k) O1 = {o1i, 1≤i≤N1} y O2 = {o2j, 1≤j≤N2}, respectivamente. Entonces existe al menos un par de objetos (o1i, o2j) perteneciendo a O1 × O2 que verifica:

) ,() ,( 2121 RRMinMaxDistoo ji ≤

Demostración:

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). £

Según el teorema 3.5, MinMaxDist(R1, R2) es una buena distancia como cota superior para el par más cercano, ya que nos garantiza la presencia del par de objetos en E(k) (o1i, o2j) más cercano, compartiendo al menos un punto de los MBR R1 y R2. Además, ésta es apropiada cuando tenemos dimensiones grandes (k≥4), puesto que su cálculo tiene coste lineal O(k).

La última métrica entre pares de MBRs que vamos a introducir es MaxMaxDist(R1, R2), que representa la distancia entre los vértices más lejanos de los MBRs R1 y R2.

Capítulo 3

88

MaxMaxDist(R1, R2) nos garantiza que en esa distancia van a estar todos los posibles pares de objetos que se pueden formar, estando incluidos en los MBRs R1 y R2. Por tanto, esta métrica nos proporciona una cota superior para los K pares más cercanos.

Definición. MaximaDistancia(R1, R2). El máximo valor de todas las máximas distancias entre los puntos que forman las caras de dos MBRs, R1 y R2, definidos en E(k), denotado como MaximaDistancia(R1, R2), se define como:

( ) ( ){ }{ }21 ,)( ),(21 ,maxmax ,22112211

ppdRRanciaMaximaDist fpfpRFfRFf ∈∈∈∈=

donde F(R1) y F(R2) son los conjuntos de caras que forma los MBRs R1 y R2, respectivamente. Además, f es una instancia de las caras que forman dichos conjuntos, y d es la distancia Euclídea entre dos puntos p1 y p2, definidos en E(k), donde p1 y p2 es un par de puntos en alguna de las caras de R1 y R2, respectivamente.

A continuación presentamos una definición algorítmica de esta distancia.

Definición. MaxMaxDist(R1, R2). Dados dos MBRs R1 = (s, t) y R2 = (p, q) en E(k), R1 = (s, t), donde s = (s1, s2, ..., sk) y t = (t1, t2, ..., tk) tal que si ≤ ti, ∀1≤i≤k, R2 = (p, q), donde p = (p1, p2, ..., pk) y q = (q1, q2, ..., qk) tal que pi ≤ qi, ∀1≤i≤k, definimos MaxMaxDist(R1, R2) de la siguiente manera:

∑=

=k

iiyRRMaxMaxDist

1

221 ) ,( ; donde, { }iiiii ptqsy −−= , max

La Figura 3.11 ilustra la métrica MaxMaxDist(Ri, Rj) definida entre dos MBRs.

R1

R2

R3

R4

Figura. 3.11 MaxMaxDist(Ri, Rj) entre dos MBRs en E(2).

Proposición 3.3. Dados dos MBRs R1 = (s, t) y R2 = (p, q) en E(k), la siguiente propiedad es cierta:

MaximaDistancia(R1, R2) = MaxMaxDist(R1, R2)

Demostración:


89

Para demostrar esta igualdad debemos probar que MaxMaxDist(R1, R2) es la mayor distancia Euclídea que existe desde cualquier punto del perímetro de R1 a cualquier otro punto del perímetro de R2.

Sabemos que la distancia Euclídea desde cualquier punto del perímetro de R1 a cualquier otro punto del perímetro de R2, viene dada por la siguiente expresión:

iiiiiiii

k

iii qbptas:ba baRRd ≤≤≤≤∀−= ∑

=

y ,,) ,(1

221

El objetivo es maximizar |ai – bi| para cada una de las dimensiones 1≤i≤k (max{|ai – bi|}). Para ello, consideramos el punto medio de los intervalos que intervienen en cada dimensión: [si, ti] tal que si ≤ ti, ∀1≤i≤k; (si + ti)/2, y [pi, qi] tal que pi ≤ qi, ∀1≤i≤k; (pi + qi)/2.

• Si (si + ti)/2 ≤ (pi + qi)/2, entonces el mayor componente del intervalo con el punto medio más lejano es qi, y el menor componente del intervalo con el punto medio más cercano es si, independientemente si los intervalos [si, ti] y [pi, qi] se solapan o no. Por tanto, max{|ai – bi|} = |si – qi|.

• Si por el contrario, (si + ti)/2 > (pi + qi)/2, entonces el mayor componente del intervalo con el punto medio más lejano es ti, y el menor componente del intervalo con el punto medio más cercano es pi, independientemente si los intervalos [si, ti] y [pi, qi] se solapan o no. Por tanto, max{|ai – bi|} = |ti – pi|. £

Teorema 3.6. Dados dos MBRs R1 y R2 de dos R*-trees en E(k), definidos como R1 = (s, t) y R2 = (p, q), envolviendo a los conjuntos de objetos en E(k) O1 = {o1i, 1≤i≤N1} y O2 = {o2j, 1≤j≤N2}, respectivamente. Entonces para todo par de objetos (o1i, o2j) perteneciendo a O1 × O2 se verifica que:

) ,() ,( 2121 RRMaxMaxDistoo ji ≤

Demostración:

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 conclusión que se puede obtener de esta última métrica es que MaxMaxDist(R1, R2) determina una cota superior de la distancia Euclídea de cualquier par de objetos formado por un objeto o1i ∈ O1 incluido en R1 y otro objeto o2j ∈ O2 incluido en R2. Además, MaxMaxDist es de utilidad para evitar la visita de nodos innecesarios en el procesamiento de una consulta para obtener los K pares más cercanos. Para concluir, enunciamos la relación existente entre MinMinDist, MaxMaxDist y la distancia entre dos objetos o1 y o2 caracterizados por sus conjuntos de caras, en forma de corolario

Capítulo 3

90

Corolario 3.1. Dados dos MBRs R1 y R2 de dos R*-trees en E(k), definidos como R1 = (s, t) y R2 = (s, t) envolviendo a los conjuntos de objetos en E(k) O1 = {o1i, 1≤i≤N1} y O2 = {o2j, 1≤j≤N2}, respectivamente. Entonces para cualquier par de objetos (o1i, o2j) perteneciendo a O1 × O2 se verifica que:

2121212121 ) ,( ), ,() ,( ) ,( OOooRRMaxMaxDistooRRMinMinDist jiji ×∈∀≤≤

Demostración:

La demostración es inmediata según los teoremas 3.4 y 3.6. £

Para finalizar con las métricas 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 más cercano y su extensión para los K pares más cercanos, vamos a ilustrarlas en la Figura 3.12.

R1

R2

MinMinDist

MinMaxDist

MaxMaxDist

Figura 3.12 MinMinDist, MinMaxDist y MaxMaxDist entre dos MBRs R1 y R2 en E(2).

Las métricas entre pares de MBRs MinMinDist(R1, R2) y MinMaxDist(R1, R2) 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 simultáneamente desde la raíz hasta las hojas según un algoritmo branch-and-bound para encontrar el par más cercano. Por otro lado, las métricas entre pares de MBRs MinMinDist(R1, R2) y MaxMaxDist(R1, R2) se utilizan en unas reglas de poda similares (teoremas 3.4 y 3.6) para encontrar los K pares más cercanos utilizando el mismo tipo de algoritmo.

3.5 Conclusiones

En este capítulo hemos definido las métricas en E(k) entre pares de MBRs y establecido sus propiedades, que nos servirán para diseñar algoritmos branch-and-bound que respondan a las consultas de los pares más cercanos de dos conjuntos de objetos indexados en sendos R*-trees. Para ello, establecemos los conceptos métricos necesarios, definimos dichas consultas y


91

planteamos ejemplos de aplicación de las mismas en el campo de las bases de datos espaciales. También, presentamos la relación que existe entre la consulta del vecino más próximo y el join espacial con la consulta de los pares más cercanos, revisando las métricas en E(k) entre un punto y un MBR, sus propiedades y las heurísticas de poda aplicadas a R*-trees.

El diseño de algoritmos branch-and-bound eficientes aplicados sobre métodos de indexación arbóreos basados en MBRs, requiere de la definición (conceptual y algorítmica), análisis e implementación de métricas entre pares de MBRs para aplicarlas en heurísticas de poda sobre dichos índices y dar respuesta a consultas de los pares más cercanos. Las métricas originales presentadas en este capítulo han sido: (1) MinMinDist(R1, R2), que representa la mínima distancia en E(k) que hay entre dos MBRs, R1 y R2, y se utiliza como cota inferior de la distancia de todos los pares más cercanos de objetos que contienen dichos MBRs; (2) MinMaxDist(R1, R2), que nos devuelve la mínima de todas las máximas distancias en E(k) entre las caras paralelas más próximas de dos MBRs, R1 y R2, en cada una de las dimensiones, y se emplea como cota superior de la distancia del par más cercano de objetos que envuelven dichos MBRs; y (3) MaxMaxDist(R1, R2), que representa la máxima distancia en E(k) que hay entre dos MBRs, R1 y R2, y se utiliza como cota superior de la distancia de todos pares más cercanos de objetos que contienen dichos MBRs.

93

Capítulo 4

ALGORITMOS PARA LA REALIZACIÓN DE LA CONSULTA

DEL PAR MÁS CERCANO UTILIZANDO R*-TREES

4.1 Introducción

La técnica branch-and-bound se utiliza con mucha frecuencia para buscar la solución óptima de un determinado problema al recorrer un árbol explícito o implícito. La idea principal de un algoritmo branch-and-bound es dividir un determinado problema inicial en un número de subproblemas parciales de tamaño más pequeño. Cada subproblema está caracterizado por la inclusión de una o más restricciones para descartar posibles subproblemas que no conduzcan a la solución óptima. El proceso de descomposición 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 solución óptima del problema inicial. Nosotros utilizaremos branch-and-bound para encontrar el par más cercano de dos conjunto de objetos almacenados en sendos R*-trees. Para diseñar algoritmos branch-and-bound sobre R*-trees debemos aplicar una función de selección que no afecta a la convergencia del algoritmo pero sí a su eficiencia y a los recursos requeridos. Las funciones de selección más comunes son: búsqueda en profundidad (recorrido en profundidad del árbol), búsqueda en anchura (recorrido en anchura del árbol), primero el mejor (selecciona siempre el menor valor de una función) y el esquema híbrido (combina un recorrido en anchura con una estrategia de selección de primero el mejor).

Capítulo 4

94

En este capítulo veremos una serie de algoritmos para dar respuesta a la consulta del par más cercano utilizando como método de indexación los R*-trees [BKS+90], es decir, los dos conjuntos de objetos van a estar indexados por sendos R*-trees. Empezaremos con las aproximaciones algorítmicas más intuitivas para dar solución a dicha consulta. La primera de ellas consiste en realizar una combinación de un recorrido en profundidad en uno de los R*-trees con una consulta del vecino más próximo sobre el otro R*-tree. La segunda es consecuencia directa del join sobre índices siguiendo un esquema de bucle anidado. La tercera aproximación es un algoritmo iterativo que utiliza un montículo para evitar la recursividad. Después de establecer estas primeras aproximaciones se presentan una serie de algoritmos branch-and-bound, para las variantes recursivas e iterativas, que utilizan unas métricas entre pares de MBRs como cotas durante el recorrido del árbol y diferentes criterios de selección de nodos, con el objetivo de obtener resultados óptimos del coste de dicha consulta. Para mejorar aún más estos algoritmos, se presentan técnicas de optimización para reducir el número de accesos a disco y el tiempo de respuesta.

4.2 Primeras aproximaciones para dar solución a la consulta del par más cercano utilizando R*-trees

Para establecer los primeros algoritmos que nos devuelvan como resultado el par más cercano debemos recordar cómo recorrer un R*-tree tanto en profundidad como en anchura. Posteriormente estudiaremos la primera aproximación, que consiste en una combinación de un recorrido en profundidad en el primero de los R*-trees con una consulta del vecino más próximo sobre el segundo R*-tree, teniendo como elemento de consulta los objetos almacenados en las hojas del primero. A continuación veremos la segunda aproximación basada en el join espacial propuesto en [BKS93a] que sigue un esquema en bucle anidado, sin utilizar ninguna métrica como mecanismo de poda. Y por último, se presenta la versión iterativa (no recursiva) utilizando un montículo para obtener la solución a la consulta del par más cercano, utilizando una función basada en niveles para organizar el montículo y ninguna métrica entre pares de MBRs como mecanismo de poda.

4.2.1 Recorridos de un R*-tree

En los dos siguientes apartados vamos a recordar cómo 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 más cercano.

Algoritmos para la realización de la consulta del par más 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 raíz como punto de partida. A continuación, si hay un nodo hijo adyacente a dicha raíz que no haya sido visitado todavía, 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 raíz 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 raíz, 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 continuación:

Recorrido_Profundidad(N: R_nodo) 01 if N no es nulo then 02 for every entrada n i de N do 03 N’ = LeerNodo(ni.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 sólo se detiene cuando la exploración del árbol se ve bloqueada o no puede proseguir. En dicho momento, la recursividad retrocede (fase de backtracking o vuelta atrás) para que sea posible estudiar posibles alternativas en niveles más 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 algún nodo, primero visita todos los hijos de dicho nodo, y sólo examina nodos en niveles más bajos después 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 (según la altura del árbol), que es una lista de elementos a manejar según 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 según la altura del árbol a recorrer), destruirCola (destruye la estructura de datos cola), estaVacia (detecta si la estructura de datos cola está vacía en un nivel determinado), ponerElemento (coloca un nuevo elemento al final de la

Capítulo 4

96

estructura de datos cola, determinada por el nivel que se le pasa como parámetro) y quitarElemento (elimina el elemento situado al principio de la estructura de datos cola, indicada por el nivel pasado como parámetro). A continuación 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(ni.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 ocurría al recorrido en profundidad.

4.2.2 Algoritmo que combina un recorrido de un R*-tree con una consulta del vecino más próximo sobre el otro R*-tree

La primera aproximación que intuitivamente pensamos cuando deseamos encontrar el par más cercano es realizar una combinación de un recorrido (en profundidad o en anchura) en uno de los R*-trees con la consulta del vecino más próximo 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 más próximos de cada uno de los objetos del primer R*-tree obtenemos el par más cercano como aquél que presenta la menor distancia.

Para obtener el par más 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 más cercano.

Como ejemplo de esta primera aproximación veremos la combinación del recorrido en profundidad siguiendo el esquema de Recorrido_Profundidad, y para la consulta del vecino más próximo podemos utilizar CVP_Recursivo [RKV95]. El par más 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 continuación:


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(pi.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 = (pi, VP); 13 endif 14 enddo 15 endif

Como sabemos, el tiempo que necesita el algoritmo para recorrer en profundidad el R*-tree RP en el que hay N nodos está en O(N). Además, en el peor caso, CVP_Recursivo sobre el R*-tree RQ en el que hay M nodos está también 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 aproximación sigue el mismo esquema que el algoritmo presentado en [BKS93a] para la solución del join espacial según 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 RP es el índice externo y RQ 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. Además, para cada objeto de RP se tiene que realizar una exploración completa en el índice de RQ.

Para obtener el par más cercano de objetos con este algoritmo debemos mantener también 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 aproximación para obtener el par más 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 raíces de los dos R*-trees y fijar la distancia del par más cercano encontrado hasta el momento, parMasCercano.distancia, a infinito (∞).

Capítulo 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 (RPi, RQj) 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 más 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(pi.direccion); 05 nQ’ = LeerNodo(qj.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(pi.MBR, qj.MBR); 13 if dist ≤ parMasCercano.distancia then 14 parMasCercano.distancia = dist; 15 parMasCercano.parObjetos = (pi, qj); 16 endif 17 enddo 18 enddo 19 endif

Suponiendo que los R*-trees RP y RQ tienen N y M nodos, respectivamente, el tiempo que necesita el algoritmo CPC_Recursivo_Fuerza_Bruta para obtener el par más 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 RP se compara con cada entrada de los nodos del índice R*-tree RQ para encontrar el par de objetos almacenados en las hojas con la menor distancia entre ellos, realizándose un recorrido recursivo en profundidad sincronizado en los dos índices R*-trees.

4.2.4 Algoritmo iterativo sobre dos R*-trees utilizando un montículo

En este apartado, antes de presentar la aproximación iterativa para encontrar el par más cercano, vamos a estudiar una estructura de datos denominada montículo y todas las operaciones que tiene asociada, debido a que ésta es el núcleo principal para la implementación de dicha aproximación.


99

4.2.4.1 Montículos

Un montículo (heap) [FSS+86, CLR90, BrB97, Seg98] es un tipo especial de árbol binario que se puede implementar eficientemente en un array sin ningún puntero explícito. Esta estructura de datos se puede utilizar para representar eficientemente listas dinámicas de prioridad.

Se dice que un árbol binario es esencialmente completo si todo nodo interno, con la posible excepción 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. Además, o bien todas las hojas se encuentran en el nivel 0, o bien están 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 máximo posible, con los nodos del último nivel desplazados hacia la izquierda; las hojas llenan el último nivel que contiene nodos internos (si queda algún espacio), y después 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 raíz) en el nivel h, dos nodos en el nivel h – 1, y así sucesivamente; hay 2h – 1 nodos en el nivel 1, y al menos uno pero no más de 2h en el nivel 0. Si el árbol contiene N nodos en el total, contando tanto los nodos internos como las hojas, se sigue que 2h ≤ N ≤ 2h+1. Análogamente, 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[2h], A[2h + 1], ..., A[2h+1 – 1], con la posible excepción 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 representación, el padre del

Capítulo 4

100

nodo representado en A[i] se encuentra en A[i / 2] para i > 1 (la raíz 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.

Definición. Montículo. Un montículo es un árbol binario esencialmente completo representado como un array, donde cada uno de sus nodos incluye un elemento de información denominado valor del nodo.

Propiedad. Propiedad del montículo. Dado un montículo, el valor de cada nodo interno es mayor o igual que los valores de sus hijos (montículo máximo). 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 montículo asegura que el valor de todo nodo interno es mayor o igual que los valores de todos los nodos que están en los subárboles situados por debajo de él. En particular, el valor de la raíz es mayor o igual que los valores de todos los demás nodos del montículo (montículo máximo).

La Figura 4.2 muestra un ejemplo de montículo 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 montículo, 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 montículo.

Este mismo montículo se puede expresar de manera idéntica 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 característica principal de esta estructura de datos es que la propiedad del montículo se puede restaurar de forma eficiente si se modifica el valor de un nodo. Si el valor de un nodo


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 montículo. Diremos que el valor modificado ha flotado hasta su nueva posición dentro del montículo (a esta operación 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 montículo. Diremos que el valor modificado se ha hundido hasta su nueva posición dentro del montículo (a esta operación se le suele denominar Hundir).

El montículo es una estructura ideal para encontrar el mayor de los elementos de un conjunto (obtenerMaximo), para eliminarlo (eliminarMaximo), para añadir un nuevo nodo (insertarElemento) o para modificar un nodo existente (modificarElemento). Casi todos estos procedimientos sobre un montículo se implementan en función de las dos operaciones básicas: Flotar y Hundir. Los anteriores procedimientos son los que se necesitan para implementar eficientemente las colas de prioridad dinámicas, donde el elemento con mayor prioridad está siempre en la raíz del montículo (montículo máximo). En [Seg98] se realiza una implementación eficiente de todos los procedimientos asociados a un montículo, 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 montículo invertido, también denominado montículo mínimo. 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 sucedía en un montículo máximo. En un montículo mínimo, el elemento más pequeño se encuentra en la raíz del montículo. Todas las propiedades de un montículo máximo pueden extenderse fácilmente a un montículo mínimo. 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 método de acceso espacial (R*-tree).

Montículo

R*-tree

Método de Acceso Espacial

Figura 4.3 Representación de un montículo como estructura de datos.

Aún cuando los montículos pueden utilizarse para implementar de forma eficiente la mayoría de las operaciones necesarias para manejar colas dinámicas 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 montículo. Una buena solución para esto es implementar una

Capítulo 4

102

tabla hash asociada a los elementos que hay almacenados en el montículo en un momento determinado.

4.2.4.2 Algoritmo iterativo utilizando un montículo

El núcleo para la implementación de la versión iterativa del algoritmo para encontrar el par más cercano es un montículo, donde cada elemento tiene un par de componentes, uno de cada índice espacial R*-tree de entrada, RP y RQ.

Para reducir el tamaño global del montículo, no se almacenan pares de elementos en los que algún 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 número máximo de pares insertados en el montículo se podría hacer como indicamos a continuación. Sean RP y RQ dos R*-trees de orden (mP, MP) y (mQ, MQ), y con alturas hP y hQ, respectivamente, entonces el número máximo de pares (MBR/MBR) procedentes de nodos internos de RP y RQ que se insertarán en el montículo es SP * SQ, donde

∑−

=

=1

1

Ph

i

iPP MS y ∑

−

=

=1

1

Qh

i

iQQ MS

Otra característica del algoritmo es que la combinación de MBRs procedentes de nodos internos de RP y RQ se hace de la forma todos con todos. Es decir, cada entrada del nodo interno de RP se combina con cada entrada del nodo interno de RQ, insertándose al final en el montículo EP * EQ pares de MBRs, donde EP y EQ representan el número de entradas para cada nodo interno de RP y RQ, respectivamente. Al algoritmo correspondiente, donde los dos R*-trees tienen la misma altura, le denominamos CPC_Monticulo_Fuerza_Bruta, cuya descripción por pasos (CPCM#) es la que se indica a continuación:

CPCM1 Comenzar desde las raíces de los dos R*-trees, fijar la distancia del par más cercano encontrado hasta el momento, parMasCercano.distancia, a infinito (∞) y crear el montículo.

CPCM2 Si se accede a un par de nodos internos (nP y nQ), insertar en el montículo todos los posibles pares de MBRs (RPi, RQj) procedentes de la combinación 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 montículo está vacío, entonces parar.

CPCM5 Obtener el par de la raíz del montículo y repetir el algoritmo desde CPCM2 para este par.


103

En este algoritmo lo más importante es establecer la clave de ordenación del montículo (en este caso, montículo mínimo). Para esta primera aproximación utilizaremos información relacionada con el nivel y la altura de los R*-trees. Por ejemplo, ésta podría ser clave = (hP – nivel(RP)) + (hQ – nivel(RQ)), donde hP, hQ, nivel(RP) y nivel(RQ) son las alturas y niveles actuales de procesamiento de los R*-trees RP y RQ, respectivamente. Además, suponemos que no se hace ningún tratamiento especial para el caso de que en el montículo existan más de un par de MBRs con el mismo valor de clave. Es fácil 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.


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((hP – pi.nivel + hQ – qj.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((hP – pi.nivel + hQ – qj.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(pi.MBR, qj.MBR); 22 if dist ≤ parMasCercano.distancia then 23 parMasCercano.distancia = dist; 24 parMasCercano.parObjetos = (pi, qj); 25 endif 26 enddo 27 enddo 28 endif 29 enddo 30 M.destruirMonticulo(); 31 return parMasCercano;

Suponiendo que los R*-trees RP y RQ tienen N y M nodos, respectivamente, el tiempo que necesita el algoritmo CPC_Monticulo_Fuerza_Bruta para obtener el par más cercano está en O(N * M), por tratarse de un recorrido en anchura sincronizado en los dos R*-trees. Además 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.

Capítulo 4

104

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

La técnica de branch-and-bound (ramificación y poda) se utiliza para explorar grafos dirigidos acíclicos, entre los que podemos encontrar a los árboles, con el objetivo de buscar la solución óptima de un determinado problema Π. Esta técnica consiste en calcular cotas relativas a soluciones parciales para limitar el número de soluciones completas a examinar. En nuestro caso, como ya sabemos, el problema que nos proponemos resolver es obtener el par más cercano de dos conjuntos de objetos almacenados en sendos R*-trees.

Además, vamos a presentar varias formas de procesamiento en algoritmos branch-and-bound que determinan el par más cercano, aplicando métricas 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 técnica general para el diseño de algoritmos [HoS78, Iba87, BrB95]. Esta técnica se puede utilizar para encontrar una solución óptima a un determinado problema cuando se recorren estructuras arbóreas. Un problema de optimización (minimización) generalmente se define de la siguiente manera:

Π: minimizar f(x) sujeto a x ∈ W

donde W ⊆ X representa una región factible del espacio subyacente X. Es decir, W es el conjunto de soluciones factibles que satisfacen las restricciones impuestas. La función f : X → ℜ donde ℜ el conjunto de los números reales, es denominada función objetivo. Una solución factible x ∈ W es óptima (mínima) si ninguna otra solución 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 número de subproblemas parciales intermedios de tamaño más pequeño. Cada subproblema está caracterizado por la inclusión de una o más restricciones que se utilizan para descartar posibles subproblemas que no conduzcan a la solución óptima. El proceso de descomposición 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 solución óptima del problema inicial. La técnica branch-and-bound es esencialmente una variante o refinamiento de la técnica backtracking (vuelta atrás) que toma información sobre la optimalidad de soluciones parciales para evitar considerar soluciones que pueden no ser óptimas, y por tanto reducir el espacio de búsqueda notablemente.


105

Siguiendo esta técnica, en cada nodo del árbol calculamos una o más cotas del posible valor de aquellas soluciones que pudieran encontrarse más adelante en el árbol. Si la cota muestra que cualquiera de estas soluciones es peor que la mejor solución hallada hasta el momento, entonces no necesitamos seguir explorando dicha parte del árbol, y ésta es podada.

En la versión más sencilla de los algoritmos branch-and-bound, el cálculo de cotas se combina con un recorrido en profundidad, y sirve para podar ciertas ramas de un árbol que no nos serán de utilidad para encontrar la solución óptima. También, las cotas calculadas se utilizan para seleccionar la primera rama, entre todas las potencialmente posibles, que parece más prometedora para explorarla.

La técnica branch-and-bound también utiliza operaciones adicionales para decidir qué nodo debe explorarse a continuación y estructuras de datos adicionales para almacenar los nodos que se han generado y que aún no han sido examinados, con el objetivo de que se exploren según el orden óptimo y se minimice el número 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 cálculo. Con una cota mejor, examinamos menos nodos, y si tenemos suerte llegaremos a una solución óptima más rápidamente. Por otra parte, puede que empleemos más 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, desperdiciándose todo el trabajo adicional efectuado en cada nodo para calcular dicha cota. En la práctica, para problemas del tamaño 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 terminología 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 más cercano de dos conjuntos de objetos indexados por sendos R*-trees con la misma altura) y f la función que deseamos minimizar (distancia Euclídea entre dos objetos). El proceso de descomposición 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 raíz de T, denotada por N0, se corresponde con el problema inicial Π0 dado y los otros nodos del árbol (Ni) se corresponden con los problemas parciales Πi. El arco (Ni, Nj) ∈ A si, y sólo si Nj es generado por Ni por descomposición. El conjunto de nodos terminales u hojas de T, denotado como H, se corresponden con aquellos problemas parciales que se resuelven sin necesidad de descomposición. El nivel de Ni ∈ T, que denotamos como L(Ni), es la longitud del camino desde N0 hasta Ni en T.

Un algoritmo branch-and-bound intenta resolver Π0 examinando sólo una pequeña parte de N (conjunto de nodos del árbol branch-and-bound T). Esto se lleva a cabo aplicando un proceso de ramificación y poda a lo largo de las ramas de T en cuyos nodos Ni los problemas parciales Πi no han sido resueltos o no se ha encontrado la solución óptima (es decir, f(Ni) > f(N0)). Para cada uno de los problemas parciales o subproblemas (Πi) que se van creando, se calcula una función cota inferior, g, aplicada al nodo de T asociado (g : N → ℜ), que ayuda a eliminar ramas innecesarias. Esta función cota representa un límite inferior de una solución óptima (mínima) para un subproblema Πi, es decir g(Ni) ≤ f(Ni) tal que Ni ∈ N. Los valores de

Capítulo 4

106

esta función cota inferior deben satisfacer las siguientes condiciones, garantizando su consistencia:

g(Ni) ≤ f(Ni), para Ni ∈ N. g(Ni) = f(Ni), para Ni ∈ H. g(Nj) ≥ g(Ni), si Nj es un descendiente de Ni.

Por otro lado, también podemos calcular valores de una función cota superior aplicada a los nodos de T, u : N → ℜ , para intentar actualizar el valor de la mejor solución posible que se puede alcanzar hasta el momento. Si al principio del algoritmo aplicamos esta función de cota superior y nos devuelve valores relativamente pequeños, entonces el proceso de poda del árbol branch-and-bound será muy eficaz para la determinación de la solución óptima. Al igual que la función cota inferior, los valores de esta función cota superior deben satisfacer las siguientes condiciones, garantizando su consistencia:

u(Ni) ≥ f(Ni), para Ni ∈ N. u(Ni) = f(Ni), para Ni ∈ H.

Debemos destacar, que no se debe aplicar u(Ni) a todos los nodos generados por el algoritmo, pues conforme evoluciona el algoritmo, la actualización de la mejor solución posible que podemos alcanzar es cada vez menos significativa. Por tanto, esta función cota superior es aplicable a nodos generados al principio del algoritmo.

Un algoritmo branch-and-bound está caracterizado por cuatro procedimientos: Selección, Ramificación, Poda y Comprobación de finalización. El significado de cada uno de ellos el siguiente:

Selección. En cualquier paso durante la ejecución de un algoritmo branch-and-bound existe un conjunto S de subproblemas que han sido generados pero aún no se han examinado. El proceso de selección escoge un único subproblema basado en una función de selección fs aplicada a N, es decir, decide qué nodo será el siguiente a explorar. Las estrategias de búsqueda aplicadas al árbol branch-and-bound utilizadas como funciones de selección son las siguientes: Primero el mejor: fs(N) = Ni, tal que g(Ni) es el valor de cota más pequeño en T. Búsqueda en profundidad: fs(N) = Ni, tal que Ni es el nodo con mayor profundidad en T. Búsqueda en anchura: fs(N) = Ni, tal que Ni es el nodo con menor profundidad en T. En el procedimiento de selección, el recorrido basado en una función de selección de primero el mejor y en profundidad se utiliza en la mayoría de las situaciones, aunque el recorrido en anchura debe tenerse en cuenta también. La estrategia de búsqueda basada en una función de selección de primero el mejor minimiza el número de problemas parciales a procesar antes de su finalización. Sin embargo, esto requiere una cantidad de memoria que puede ser una función exponencial del tamaño del problema y la mejor cota suele encontrarse en la fase final del algoritmo [Iba87]. Además, esta estrategia de búsqueda tiene un inconveniente, ya que en algunos casos la solución óptima se alcanza después de haber procesado casi por completo el árbol branch-and-bound. Por otro lado, el recorrido en profundidad requiere una cantidad de memoria que sólo es una función lineal del tamaño del problema [Iba87] y conduce más rápidamente a la obtención de una mejor cota. Sin embargo, si entramos en un subárbol que no lleva a ninguna solución óptima, se requieren operaciones adicionales para salir de ese subárbol, y además el número de subproblemas inspeccionados es normalmente mayor que el


107

realizado por la función de selección de primero el mejor [Iba87]. Sin embargo, esta estrategia de búsqueda da prioridad los nodos del árbol branch-and-bound que tienen una mayor profundidad, pudiéndose disponer de soluciones aproximadas (aunque éstas no sean las óptimas) antes de la finalización 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 búsqueda, aunque hay situaciones en las que aplicando técnicas apropiadas de optimización global es una alternativa a tener en cuenta.

Ramificación. Para un problema específico se utiliza una determinada regla de ramificación que genera nuevos subproblemas más pequeños de uno establecido en el procedimiento de selección. Después de generar estos nuevos subproblemas, se calculan los valores de la función cota inferior (g) y opcionalmente los valores de la función cota inferior (u) asociados a ellos.

Poda o Eliminación. Los nuevos subproblemas creados en el procedimiento de ramificación se podan si los valores de cota (g) son estrictamente mayores que la mejor solución posible encontrada hasta el momento durante el proceso de búsqueda.

Comprobación de finalización. El algoritmo branch-and-bound termina cuando la lista de subproblemas está vacía y la mejor solución posible encontrada hasta el momento es la solución óptima del problema original. Además, se pueden definir algunas reglas auxiliares que ayuden a identificar soluciones parciales posibles.

A continuación 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 solución óptima (mínimo) en base a un determinado parámetro, distinguiendo un tratamiento diferente según el tipo de nodo (interno u hoja) procesado. Si N es el número 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(ni.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 aclaración al algoritmo anterior, se puede observar que en las líneas 4 y 5 se lleva a cabo el proceso de selección, 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 ramificación se realiza en la línea 2, donde se generan los nuevos subproblemas a procesar (la

Capítulo 4

108

línea 9 procesa las entradas del nodo hoja (terminal), no dando lugar a ramificación). En la línea 3 se lleva a cabo el proceso de poda, donde los nuevos subproblemas generados en la fase de ramificación se descartan según el valor de una cota (la línea 10 no considera posibles soluciones que estén por encima de una cota, que es el menor valor encontrado hasta el momento de una función métrica aplicada a un elemento del árbol). Por último, la comprobación de finalización 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 más 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 cuestión. En nuestro caso: Π ≡ obtener el par más cercano de dos conjuntos de objetos almacenados en sendos R*-trees (RP y RQ); f ≡ distancia Euclídea entre dos objetos espaciales; g ≡ mínima distancia Euclídea entre los elementos de dos R*-trees, u ≡ máxima distancia Euclídea entre los elementos de dos R*-trees (y mínima de todas las máximas distancias Euclídeas entre las caras que forman los elementos de dos R*-trees), y al principio, el nivel de N0 es igual a max{altura(RP), altura(RQ)}.

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 combinación de los dos R*-trees de entrada (RP y RQ). En este caso, el árbol branch-and-bound va a ser una “pila” (estructura LIFO) de pares de MBRs cuya clave de ordenación 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 mayoría de los lenguajes de programación, mediante la expansión 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.

Selección. El par de MBRs con menor MinMinDist(RPi, RQj) es el mejor candidato de todos los que tienen la misma profundidad.

Ramificación. El procedimiento de ramificación consiste en generar una lista de pares de MBRs procedentes de la expansión y combinación de dos nodos internos, uno procedente de RP y otro de RQ. Cuando ambos nodos son hojas, se resuelven sin necesidad de ramificación.

Poda. El procedimiento de eliminación o poda compara el valor de MinMinDist(RPi, RQj) de un par de MBRs procedentes de la lista de pares de MBRs generada en el


109

procedimiento de ramificación con el valor de distancia del par más cercano obtenido hasta el momento, podando todos aquellos pares cuyo valor es estrictamente mayor. Debido a que no hay ramificación entre pares procedentes de la combinación de nodos hoja, tampoco se aplica ninguna poda sobre ellos. Además, podemos aplicar un proceso adicional, previo al anterior, para actualizar la distancia del par más cercano encontrado hasta el momento, si es posible, con el mínimo valor de MinMaxDist(RPi, RQj) aplicada a todos los pares de MBRs procedentes de la lista generada en la fase de ramificación. MinMaxDist(RPi, RQj) es una cota superior para la distancia del par más cercano de los conjuntos de objetos envueltos por los MBRs RPi y RQj.

Comprobación de finalización. 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(RPi, RQj) estrictamente mayor que la distancia del par más cercano encontrado hasta el momento.

Tercer paso. La solución óptima a nuestro problema (encontrar el par más cercano) es el par global de objetos obtenido del proceso de ramificación y poda.

La versión iterativa utilizando un montículo del algoritmo branch-and-bound basado en una función de selección de primero el mejor consiste también en tres pasos que describimos a continuación:

Primer paso. Empezar a generar el árbol branch-and-bound que se obtiene de la combinación de los dos R*-trees de entrada (RP y RQ). El árbol branch-and-bound va a ser un montículo mínimo de pares de MBRs cuya clave de ordenación es MinMinDist(RPi, RQj). Es decir, va a ser un montículo en el que el par de MBRs con menor MinMinDist(RPi, RQj) estará ubicado en la raíz, siendo esta métrica una cota inferior para detectar el par más cercano.


Selección. El procedimiento de selección consiste en escoger el par de MBRs ubicado en la raíz del montículo mínimo, que es el que tiene menor valor de MinMinDist(RPi, RQj) entre todos los pares de MBRs que forman dicho montículo. Este proceso de selección da lugar a un recorrido basado en una función de selección de primero el mejor.

Ramificación. El procedimiento de ramificación consiste en generar todos los pares de MBRs procedentes de la combinación de dos nodos internos (procedentes de RP y RQ), calcular su MinMinDist(RPi, RQj), y prepararlos para su inserción en el montículo mínimo.

Poda. Cuando se van a insertar los pares de MBRs en el montículo mínimo, después del procedimiento de ramificación, se descartan todos aquellos pares cuya MinMinDist(RPi, RQj) es estrictamente mayor que el par más cercano obtenido hasta el momento. En este procedimiento, también se puede aplicar opcionalmente el valor del mínimo de MinMaxDist(RPi, RQj) calculado entre todos los pares de MBRs procedentes de la combinación de dos nodos internos, para actualizar la distancia del par más cercano encontrado hasta el momento (reduce el número de pares insertados en el montículo mínimo).

Capítulo 4

110

Comprobación de finalización. El algoritmo branch-and-bound se detiene si, y sólo si el montículo está vacío o el par situado en la raíz de dicho montículo tiene un valor de MinMinDist(RPi, RQj) estrictamente mayor que la distancia del par más cercano encontrado hasta el momento.

Tercer paso. La solución óptima a nuestro problema es el par de objetos generado a nivel global del proceso de ramificación y poda.

Por último, la versión iterativa del algoritmo branch-and-bound siguiendo en un recorrido en anchura y combinado con una función de selección de primero el mejor sobre un conjunto de montículos organizado por niveles consiste en otros tres pasos:

Primer paso. Empezar a generar el árbol branch-and-bound que se obtiene de la combinación de los dos R*-trees de entrada (RP y RQ). El árbol branch-and-bound va a ser un conjunto de montículos mínimos organizado por niveles, para los cuales la clave de ordenación es MinMinDist(RPi, RQj). Es decir, se va a crear un montículo mínimo por cada nivel, donde el par de MBRs con menor MinMinDist(RPi, RQj) estará ubicado en la raíz, y hasta que no se procesa completamente un nivel, no se pasa al siguiente.


Selección. El procedimiento de selección consiste en escoger el par de MBRs ubicado en la raíz (menor valor de MinMinDist(RPi, RQj)) del montículo mínimo no vacío del nivel más alto. Este proceso de selección da lugar a un recorrido en anchura combinado con un proceso de selección de primero el mejor.

Ramificación. El procedimiento de ramificación consiste en generar todos los posibles pares de MBRs procedentes de la combinación de dos nodos internos (de los R*-trees RP y RQ), calcular su MinMinDist(RPi, RQj), y prepararlos para su inserción en el montículo mínimo del nivel inmediatamente inferior.

Poda. Cuando se van a insertar los pares de MBRs en el montículo mínimo del nivel inmediatamente inferior, después del procedimiento de ramificación, se descartan todos aquellos pares cuya MinMinDist(RPi, RQj) es estrictamente mayor que el par más cercano obtenido hasta el momento. También podemos aplicar opcionalmente en este procedimiento la actualización de la distancia del par más cercano obtenido hasta el momento con el mínimo valor de MinMaxDist(RPi, RQj), si esto es posible.

Comprobación de finalización. El algoritmo branch-and-bound se detiene, si y sólo si, todos los montículos mínimos por niveles están totalmente vacíos o los pares situados en sus raíces tienen un valor de MinMinDist(RPi, RQj) estrictamente mayor que la distancia del par más cercano encontrado hasta el momento.

Tercer paso. La solución óptima a nuestro problema es el par de objetos generado a nivel global del proceso de ramificación y poda.


111

4.3.3 Reglas de poda basadas en distancias para los algoritmos branch-and-bound que determinan el par más cercano

Las distancias, MinMinDist(R1, R2) y MinMaxDist(R1, R2), definidas en el capítulo 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 raíz hasta las hojas, según algoritmos branch-and-bound para encontrar el par más cercano. Las reglas son las siguientes:

1. Por el teorema 3.4. Si parMasCercano.distancia es la distancia Euclídea del par más cercano encontrado hasta el momento, entonces todos los pares de MBRs (RPi, RQj) tal que RPi ∈ RP y RQj ∈ RQ, con distancia MinMinDist(RPi, RQj) estrictamente mayor que parMasCercano.distancia pueden descartarse, ya que estos pares de MBRs no incluirán 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 (RPi, RQj) tal que RPi ∈ RP y RQj ∈ RQ tiene un valor de MinMinDist(RPi, RQj) mayor que MinMaxDist(R’Pi, R’Qj) de otro par de MBRs (R’Pi, R’Qj) tal que R’Pi ∈ RP y R’Qj ∈ RQ, entonces el par (RPi, RQj) puede descartarse, porque no puede contener al par más cercano. Además, si parMasCercano.distancia es la distancia del par más cercano encontrado hasta el momento, entonces podemos actualizarla de la siguiente forma: si MinMaxDist(RPi, RQj) < parMasCercano.distancia, entonces parMasCercano.distancia = MinMaxDist(RPi, RQj). Debemos destacar que MinMaxDist(RPi, RQj) sólo se utiliza (opcionalmente) como métrica para la actualización de parMasCercano.distancia entre pares de MBRs cuando pretendemos encontrar el par más cercano.

En la Figura 4.4 se pueden observar los posibles pares de MBRs aceptados ((RP1, RQ2) y (RP2, RQ2)) y descartados ((RP1, RQ1) y (RP2, RQ1)) aplicando las estrategias de poda basadas en MinMaxDist(RPi, RQj) para encontrar el par más cercano. Realmente aplicamos la estrategia (2) ya que el ejemplo es sobre pares de MBRs y el mínimo valor para MinMaxDist(RPi, RQj) es MinMaxDist(RP2, RQ2), descartando todos los pares de MBRs que verifiquen la siguiente condición: MinMinDist(RPi, RQj) > MinMaxDist(RP2, RQ2), y en nuestro ejemplo son (RP1, RQ1) y (RP2, RQ1).

Capítulo 4

112

RP1 RQ1

mínima MinMaxDist

RP2 RQ2

MinMinDist MinMaxDist

Figura 4.4 Aplicación de las estrategias de poda para encontrar el par más cercano.

Es preciso destacar que para realizar la consulta del par más 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 más cercano

En este apartado vamos a presentar una serie de refinamientos del algoritmo recursivo CPC_Fuerza_Bruta (recorrido en profundidad) en su versión branch-and-bound, utilizando para ello las métricas entre pares de MBRs y reglas de poda vistas anteriormente. También se presenta una variante en la que se aplica una técnica muy conocida en geometría computacional denominada Barrido del Plano [PrS85], para no considerar la combinación de todas las entradas de un nodo interno de RP con todas las entradas de un nodo interno de RQ, 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 más 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 solución óptima. Esto quiere decir, propagar el algoritmo hacia abajo sólo para aquellos pares de MBRs (RPi, RQj) procedentes de la combinación de dos nodos internos de ambos R*-trees (con la misma altura) verificando que su mínima distancia es menor o igual que la distancia del par más cercano de objetos encontrado hasta el momento, MinMinDist(RPi, RQj) ≤ parMasCercano.distancia. Al algoritmo le vamos a


113

denominar CPC_Recursivo_MINMINDIST y el paso CPCR2 del algoritmo CPC_Fuerza_Bruta ahora debería ser:

CPCR2 Si se accede a un par de nodos internos (nP y nQ), calcular MinMinDist(RPi, RQj) para cada posible par de MBRs (RPi, RQj) y propagar recursivamente hacia abajo en los dos R*-trees sólo para aquellos pares de MBRs (RPi, RQj) que verifiquen MinMinDist(RPi, RQj) ≤ parMasCercano.distancia.

El par de objetos más 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(pi.MBR, qj.MBR) ≤ parMasCercano.distancia then 05 nP’ = LeerNodo(pi.direccion); 06 nQ’ = LeerNodo(qj.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(pi.MBR, qj.MBR); 15 if dist ≤ parMasCercano.distancia then 16 parMasCercano.distancia = dist; 17 parMasCercano.parObjetos = (pi, qj); 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 más cercano consiste en intentar minimizar el valor de parMasCercano.distancia (distancia del par más 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 (RPi, RQj), comprobamos si MinMaxDist(RPi, RQj) aplicada a cada par de MBRs puede producir un valor de parMasCercano.distancia más pequeño. 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 más cercano. Al algoritmo le vamos a denominar CPC_Recursivo_MINMAXDIST_MINMINDIST y el paso CPCR2 respecto del algoritmo CPC_Recursivo_MINMINDIST ahora debería ser:

Capítulo 4

114

CPCR2 Si se accede a un par de nodos internos (nP y nQ), calcular el mínimo MinMaxDist(RPi, RQj) para cada posible par de MBRs (RPi, RQj), y si es menor que parMasCercano.distancia, actualizar parMasCercano.distancia. Calcular MinMinDist(RPi, RQj) y propagar recursivamente hacia abajo en los dos R*-trees sólo para aquellos pares de MBRs (RPi, RQj) que verifiquen MinMinDist(RPi, RQj) ≤ parMasCercano.distancia.

El par más 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(pi.MBR, qj.MBR) < parMasCercano.distancia then 05 parMasCercano.distancia = MinMaxDist(pi.MBR, qj.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(pi.MBR, qj.MBR) ≤ parMasCercano.distancia then 12 nP’ = LeerNodo(pi.direccion); 13 nQ’ = LeerNodo(qi.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(pi.MBR, qj.MBR); 22 if dist ≤ parMasCercano.distancia then 23 parMasCercano.distancia = dist; 24 parMasCercano.parObjetos = (pi, qj); 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 gráfica (Figura 4.5) a título de ejemplo.


115

RP1 RQ1 mínima MinMaxDist

RP2

RQ2

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 (rectángulos minimales en líneas discontinuas) que contienen dos MBRs (rectángulos minimales en línea continua) y las distancias MinMaxDist(RPi, RQj) y MinMinDist(RPi, RQj) entre cada par de MBRs. La mínima MinMaxDist(RPi, RQj) es la del par (RP1, RQ2). Supongamos que este valor es menor que parMasCercano.distancia, por tanto parMasCercano.distancia se actualiza con MinMaxDist(RP1, RQ2). Es evidente que MinMinDist(RP2, RQ1) > MinMinDist(RP1, RQ1) > parMasCercano.distancia. Esto significa que las ramas correspondientes a los pares de MBRs (RP2, RQ1) y (RP1, RQ1) se podarán.

4.4.3 Algoritmo branch-and-bound recursivo MINMAXDIST_MINMINDIST Ordenado

Una mejora del algoritmo CPC_Recursivo_MINMAXDIST_MINMINDIST para la consulta del par más cercano está basada en la idea de que los pares de MBRs que tienen menor MinMinDist(RPi, RQj), tienen mayor probabilidad de contener el par más cercano, dando lugar a un menor valor para parMasCercano.distancia (distancia del par de objetos más cercano encontrado hasta el momento) más rápidamente conforme se procesan dichos pares, generando así el par más cercano con mayor rapidez. Dicha mejora se produce cuando se accede a dos nodos internos. Se ordenan los pares de MBRs (RPi, RQj) generados de la combinación de MBRs de ambos nodos en orden ascendente de MinMinDist(RPi, RQj), y se propaga hacia abajo recursivamente el algoritmo sobre los dos R*-trees según 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 solución óptima. Al algoritmo le vamos a denominar CPC_Recursivo_MINMAXDIST_MINMINDIST_Ordenado y el paso CPCR2 respecto del algoritmo CPC_Recursivo_MINMAXDIST_MINMINDIST ahora debería ser:

CPCR2 Si se accede a un par de nodos internos (nP y nQ), calcular el mínimo MinMaxDist(RPi, RQj) para cada posible par de MBRs (RPi, RQj), y si es menor

Capítulo 4

116

que parMasCercano.distancia, actualizar parMasCercano.distancia. Calcular MinMinDist(RPi, RQj) y ordenar todos los posibles pares de MBRs (RPi, RQj) en orden ascendente de MinMinDist(RPi, RQj). Siguiendo este orden, propagar recursivamente hacia abajo en los dos R*-trees sólo para aquellos pares de MBRs (RPi, RQj) que verifiquen MinMinDist(RPi, RQj) ≤ parMasCercano.distancia.


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(pi.MBR, qj.MBR); 08 LISTAMINMINDIST[t].direccion_nP = pi.direccion; 09 LISTAMINMINDIST[t].direccion_nQ = qj.direccion; 10 if MinMaxDist(pi.MBR, qj.MBR) < parMasCercano.distancia then 11 parMasCercano.distancia = MinMaxDist(pi.MBR, qj.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(pi.MBR, qj.MBR); 28 if dist ≤ parMasCercano.distancia then 29 parMasCercano.distancia = dist; 30 parMasCercano.parObjetos = (pi, qj); 31 endif 32 enddo 33 enddo 34 endif

En la Figura 4.5, el orden de pares de MBRs que seguiría el algoritmo en base a MinMinDist(RPi, RQj) es: (RP1, RQ2), (RP2, RQ2), (RP1, RQ1) y (RP2, RQ1), pero los únicos pares que procesaríamos serían (RP1, RQ2) y (RP2, RQ2), ya que su valor de MinMinDist(RPi, RQj) es menor que el mínimo de MinMaxDist(RPi, RQj) determinado por (RP1, RQ2).

Debido a que los diferentes algoritmos de ordenación suelen dar en general un orden diferente, cuando un mismo valor aparece varias veces, la elección de un algoritmo de ordenación afecta al comportamiento del algoritmo que encuentra el par más cercano. Se han


117

probado casi todos los algoritmos de ordenación conocidos (QuickSort, MergeSort, HeapSort, Inserción, Selección, Burbuja, etc.) sobre LISTAMINMINDIST, y el que ha proporcionado en todos los casos una mejor ordenación 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 ordenación de todos posibles pares de MBRs procedentes de la combinación de dos nodos internos de sendos R*-trees según su MinMinDist(RPi, RQj).

En este algoritmo pueden aparecer pares de MBRs con el mismo valor de MinMinDist(RPi, RQj) en la lista LISTAMINMINDIST, sobre todo cuando hay un elevado grado de solape entre los MBRs almacenados en nodos internos (muchos pares con MinMinDist(RPi, RQj) = 0). Por esta razón, 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(RPi, RQj). A continuación presentamos ocho criterios para el tratamiento de dichos empates, manteniendo el mismo orden de elementos en LISTAMINMINDIST según MinMinDist(RPi, RQj) generado de aplicar un método de ordenación determinado. Así, en caso de que dos o más pares de MBRs tengan el mismo valor de MinMinDist(RPi, RQj), podemos elegir el par que tenga:

1. El menor nivel de los componentes de cada par. En caso de empate, según el MBR más pequeño en función de su área.

2. El mayor nivel de los MBRs que forman el par. En caso de empate, según el MBR más grande en función de su área. El área de un MBR se expresa como un porcentaje del área de la raíz de su R*-tree.

3. El menor valor de MinMaxDist(RPi, RQj) 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. Política 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. Política 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 montículo mínimo utilizando como clave de ordenación MinMinDist(RPi, RQj), donde el tiempo empleado para insertar un elemento y eliminar el mínimo está en O(logN) [Seg98]. Además, organizando LISTAMINMINDIST como un montículo mínimo evitamos realizar la operación de ordenación (coste de al menos O(N * logN)) en la línea 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. También debemos indicar que los diferentes criterios para el tratamiento de pares con el mismo valor de MinMinDist(RPi, RQj) expuestos anteriormente son perfectamente

Capítulo 4

118

aplicables sobre LISTAMINMINDIST organizada como un montículo mínimo. Al algoritmo le vamos a denominar CPC_Recursivo_MINMAXDIST_MINMINDIST_Ordenado_M y se presenta a continuación:

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(pi.MBR, qj.MBR), pi.direccion, q j.direccion); 06 if MinMaxDist(pi.MBR, qj.MBR) < parMasCercano.distancia then 07 parMasCercano.distancia = MinMaxDist(pi.MBR, qj.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(pi.MBR, qj.MBR); 22 if dist ≤ parMasCercano.distancia then 23 parMasCercano.distancia = dist; 24 parMasCercano.parObjetos = (pi, qj); 25 endif 26 enddo 27 enddo 28 endif

4.4.4 Algoritmo branch-and-bound recursivo utilizando la técnica de Barrido del Plano

Otra aproximación para mejorar la consulta del par más cercano consiste en ordenar los MBRs de los nodos de ambos R*-trees de acuerdo con sus valores de coordenadas según una dimensión y después “barrer el plano” de izquierda a derecha sobre uno de los ejes (dimensiones). A esta técnica se le conoce con el nombre de Barrido del Plano (plane-sweep) [PrS85] y se suele utilizar para el cálculo de intersecciones entre objetos, como ocurre en el join espacial con el predicado solapa presentado en [BKS93a], reduciendo el tiempo de respuesta. Esta técnica, con pequeñas modificaciones, la utilizaremos para obtener el par más cercano.


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(RPi, RQj) ≤ parMasCercano.distancia. Se genera entonces una ventana deslizante con longitud igual a parMasCercano.distancia más la longitud del MBR pivote actual en la dimensión de barrido. Por ejemplo, en la Figura 4.6 podemos observar que el MBR RP1 de un nodo de RP se escoge como pivote y se empareja con los MBRs RQ1, RQ2, RQ3 y RQ4 de un nodo de RQ, 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).

RQ7 RQ4

RQ1

Eje de Barrido

RQ3

RQ5

RQ6

RP1 RP2

RP4

RP5

RP6

RP3 RQ2

parMasCercano.distancia

Ventana Deslizante

Figura 4.6 Procesamiento de pares de MBRs con la técnica de Barrido del Plano.

Como se demuestra en [SML00], la distancia sobre el eje (dimensión) de barrido de cualquier par de MBRs, MinMinDist(RPi, RQj, ejeBarrido) es siempre menor o igual que la distancia real entre ellos, MinMinDist(RPi, RQj). Es decir, MinMinDist(RPi, RQj, ejeBarrido) ≤ MinMinDist(RPi, RQj). Todos los MBRs que tengan MinMinDist(pivote, MBR, ejeBarrido) > parMasCercano.distancia pueden descartarse respeto a dicho pivote, ya que no contendrán nunca el par más cercano. Además, el cálculo de la distancia sobre el eje de barrido para un par de MBRs es menos costoso que el cálculo de MinMinDist(RPi, RQj), ya que, entre otras cosas, se evita realizar el cálculo de una raíz cuadrada y la influencia de otras dimensiones en el cálculo de la distancia. Por todo esto, MinMinDist(RPi, RQj) se calcula sólo 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 número menor de cálculos de distancias entre pares de MBRs (MinMinDist(RPi, RQj)), dando lugar a un ahorro considerable en el tiempo de respuesta de la consulta.

Como hemos comentado anteriormente, esta técnica consiste en una ordenación y un barrido del plano. Para realizar dicha ordenación de los MBRs en el espacio sin perder la propiedad de localidad, debemos escoger un eje y una dirección de barrido [SML00].

En primer lugar se establece un eje (dimensión) de barrido, ya que cuanto más dispersos estén los MBRs en el espacio a lo largo de una dimensión, 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 número de pares de ramas que se podarán en ambos R*-trees será mayor. O equivalentemente, si en una dimensión los MBRs están muy

Capítulo 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 serán muchos los pares de ramas que se explorarán y muy pocos los que se podarán. En [SML00] se introduce una métrica denominada índice de barrido, que es una estimación normalizada del número de pares de MBRs para los que es necesario calcular su distancia, escogiéndose como eje de barrido a la dimensión con el menor índice de barrido. En la Figura 4.7 se muestran dos nodos con MBRs. Para este caso la mejor selección del eje de barrido es el eje Y, ya que los MBRs están más dispersos en esa dimensión. Por otro lado, si escogemos la dimensión X como eje de barrido ningún 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

parM

asC

erca

no.d

ista

ncia

Figura 4.7 Efecto de la selección de un eje de barrido.

Una vez establecido el eje de barrido, debemos fijar una dirección de barrido para ordenar (ascendente o descendentemente) los MBRs de un nodo según su menor valor del intervalo en dicho eje. En [SML00] la dirección 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 más pequeña que la longitud del intervalo derecho, entonces la dirección de barrido determinará una ordenación ascendente; si ocurre el caso contrario (longitud del intervalo derecho es menor que la longitud del intervalo izquierdo) la dirección de barrido dará lugar a una ordenación descendente.

En la Figura 4.8 se consideran los tipos de pares de MBRs (RPi, RQj) proyectados sobre el eje de barrido (X). La proyección de MBRs sobre el eje de barrido genera tres intervalos cerrados, a menos que los MBRs estén completamente solapados. En la Figura 4.8.a, podemos contemplar el caso en que la proyección del par de MBRs sobre el eje de barrido se solapan, un intervalo en la izquierda es generado por RPi, uno en la mitad por RPi y RQj, y otro a la derecha por RQj. En la Figura 4.8.b, se puede observar el caso de ausencia del intervalo mitad puesto que los dos intervalos de proyección 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.


121

RQj

Eje de Barrido

RPi RQj

RPi

RQj

RPi

(a) (b) (c)

Figura 4.8 Tres tipos de pares de MBRs proyectados sobre el eje de barrido.

Es decir, con la selección 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 más efectiva, mientras que con la selección de una dirección de barrido hacemos que el valor de parMasCercano.distancia se reduzca con mayor rapidez.

Una vez establecidos los criterios de ordenación debemos explicar el proceso de barrido del plano. Para ello, primero ordenamos según dichos criterios los nodos nP y nQ de los R*-trees RP y RQ, respectivamente. Por tanto, de esta ordenación obtenemos que RPi.min ≤ RPi+1.min : 0≤i<|nP| y RQj.min ≤ RQj+1.min : 0≤j<|nQ|, donde min representa el menor valor del intervalo asociado al MBR según el eje de barrido, y |nP| y |nQ| el número de entradas de nP y nQ, respectivamente. Después, cogemos un MBR pivote que no ha sido procesado hasta el momento de nP o de nQ dependiendo si RPi.min < RQj.min o RPi.min ≥ RQj.min. A continuación, dicho MBR pivote, lo emparejamos con los restantes MBRs no marcados del otro nodo ordenado. Por ejemplo, si el pivote es RPi, lo emparejamos con todos los MBRs de nQ (RQj) no marcados hasta el momento. Una vez obtenido un par de MBRs candidatos, para que estos puedan procesarse deberán cumplir dos condiciones: la primera de ellas es que todos los pares de MBRs que tienen una MinMinDist(RPi, RQj, ejeBarrido) > parMasCercano.distancia son descartados respecto del MBR pivote, la segunda condición escoge como pares de MBRs para ser procesados en la búsqueda del par más cercano los que tengan MinMinDist(RPi, RQj) ≤ parMasCercano.distancia (donde RPi o RQj 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 debería ser:

CPCR2 Si se accede a un par de nodos internos (nP y nQ), ordenar ambos nodos según los criterios del eje y dirección 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 sólo para aquellos pares de MBRs (RPi, RQj) que verifiquen MinMinDist(RPi, RQj, ejeBarrido) ≤ parMasCercano.distancia y MinMinDist(RPi, RQj) ≤ parMasCercano.distancia (donde RPi o RQj 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.


Capítulo 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.qk.MBR, ejeBarrido) ≤ parMasCercano.distancia then 11 if MinMinDist(nP.p i.MBR, nQ.qk.MBR) ≤ parMasCercano.distancia then 12 nP’ = LeerNodo(nP.p i.direccion); 13 nQ’ = LeerNodo(nQ.qk.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.pk.MBR, nQ.q j.MBR, ejeBarrido) ≤ parMasCercano.distancia then 26 if MinMinDist(nP.pk.MBR, nQ.q j.MBR) ≤ parMasCercano.distancia then 27 nP’ = LeerNodo(nP.pk.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(pi.MBR, qj.MBR); 43 if dist ≤ parMasCercano.distancia then 44 parMasCercano.distancia = dist; 45 parMasCercano.parObjetos = (pi, qj); 46 endif 47 enddo 48 enddo 49 endif

En el algoritmo CPC_Recursivo_Barrido_Plano a nivel de hojas (líneas 40-48), en lugar de combinar todas las entradas de un nodo hoja del R*-tree RP (nP) con todas las entradas de un nodo hoja del R*-tree RQ (nQ), se puede aplicar también la técnica de Barrido del Plano, quedando el algoritmo de la siguiente forma cuando se combinan dos nodos hoja (a partir de la línea 40):


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(pi, qk, ejeBarrido) ≤ parMasCercano.distancia then 49 dis t = MinMinDist(pi.MBR, qk.MBR); 50 if dist ≤ parMasCercano.distancia then 51 parMasCercano.distancia = dist; 52 parMasCercano.parObjetos = (pi, qk); 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(pk, qj, ejeBarrido) ≤ parMasCercano.distancia then 64 dist = MinMinDist(pk.MBR, qj.MBR); 65 if dist ≤ parMasCercano.distancia then 66 parMasCercano.distancia = dist; 67 parMasCercano.parObjetos = (pk, qj); 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 número de MBRs que intervienen en el emparejamiento para el nodo de RP y RQ, respectivamente, y δ es el número de pares de MBRs cuya MinMinDist(RPi, RQj, ejeBarrido) es menor o igual que parMasCercano.distancia (donde RPi o RQj puede ser el MBR pivote). La complejidad de aplicar la técnica de Barrido del Plano para esta variante de nuestro algoritmo, justifica el coste adicional de la ordenación de ambos nodos (nP y nQ), ya que en otro caso el coste global de emparejar dichos nodos sería O(|nP| * |nQ|).

Capítulo 4

124

4.5 Algoritmos branch-and-bound iterativos utilizando un montículo para encontrar el par más cercano

En este apartado, al igual que ocurría en el apartado 4.4, vamos a presentar una serie de mejoras para el algoritmo iterativo basado en un montículo CPC_Monticulo_Fuerza_Bruta en su versión branch-and-bound para obtener el par más cercano, utilizando para ello las métricas entre pares de MBRs y reglas de poda vistas en el capítulo 3. También, al igual que ocurría con la versión recursiva, se va a utilizar la técnica de Barrido del Plano para el algoritmo iterativo.

La característica principal de la versión branch-and-bound iterativa es que establece como clave de ordenación para el montículo a MinMinDist(RPi, RQj), minimizando el número de pares de MBRs a procesar. La estructura de datos utilizada para evitar la recursividad va a ser un montículo mínimo, en el que el par con menor valor de MinMinDist(RPi, RQj) se encuentra en la raíz. Este par determina los nodos a visitar y los próximos candidatos a generar.

Debemos destacar que durante la ejecución del algoritmo, al extraer el par situado en la raíz del montículo (que es el que tiene el mínimo valor de MinMinDist(RPi, RQj) hasta el momento), puede haber más de un par con el mismo valor de clave de ordenación. Por tanto, podemos aplicar los mismos criterios establecidos en CPC_Recursivo_MINMAXDIST_MINMINDIST_Ordenado para el tratamiento de empates sobre el montículo a nivel global, a los pares de MBRs que tengan el mismo valor de MinMinDist(RPi, RQj) que el par situado en la raíz del montículo en el momento de extraerlo para ser procesado.

Al igual que ocurría con la versión 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(RPi, RQj) igual a 0 y que estén almacenados en el montículo durante la ejecución del algoritmo. Esta situación puede provocar que el algoritmo sea más lento al devolver los resultados. Por consiguiente, se hace necesario buscar un compromiso entre el tratamiento de pares con el mismo valor de MinMinDist(RPi, RQj) a nivel global sobre el montículo (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 montículo

La primera mejora del algoritmo CPC_Monticulo_Fuerza_Bruta para la consulta del par más cercano consiste en hacer uso del teorema 3.4 (regla de poda 1) y podar las ramas de ambos R*-trees que verifiquen MinMinDist(RPi, RQj) > parMasCercano.distancia, al igual que


125

ocurría con CPC_Recursivo_MINMINDIST en la versión recursiva. Por este motivo, se insertan en el montículo todos los pares de MBRs procedentes de la combinación de dos nodos internos de ambos R*-trees que verifiquen MinMinDist(RPi, RQj) ≤ parMasCercano.distancia. Otra mejora consiste en extraer todos los pares situados en la raíz del montículo mientras M.obtenerMinimo().distancia ≤ parMasCercano.distancia, y detenerse si se verifica lo contrario. A esta primera versión iterativa que utiliza un montículo, la denominaremos CPC_Monticulo_MINMINDIST y los pasos CPCM2 y CPCM4 del algoritmo CPC_Monticulo_Fuerza_Bruta ahora deberían ser:

CPCM2 Si se accede a un par de nodos internos (nP y nQ), calcular MinMinDist(RPi, RQj) para cada posible par de MBRs (RPi, RQj) e insertar en el montículo todos los pares de MBRs (RPi, RQj) que verifiquen la condición de que MinMinDist(RPi, RQj) ≤ parMasCercano.distancia.

CPCM4 Si el montículo está vacío o M.obtenerMinimo().distancia > parMasCercano.distancia, entonces parar.


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(pi.MBR, qj.MBR) ≤ parMasCercano.distancia then 06 M.insertarElemento(MinMinDist(pi.MBR, qj.MBR), pi.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(pi.MBR, qj.MBR) ≤ parMasCercano.distancia then 19 M.insertarElemento(MinMinDist(pi.MBR, qj.MBR), pi.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(pi.MBR, qj.MBR); 27 if dist ≤ parMasCercano.distancia then 28 parMasCercano.distancia = dist; 29 parMasCercano.parObjetos = (pi, qj); 30 endif 31 enddo 32 enddo 33 endif

Capítulo 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 montículo

Un refinamiento para el algoritmo CPC_Monticulo_MINMINDIST para la consulta del par más cercano, al igual que para CPC_Recursivo_MINMAXDIST_MINMINDIST en la versión recursiva, consiste en intentar minimizar a nivel local el valor de parMasCercano.distancia utilizando el teorema 3.5 (regla de poda 2), produciendo un número menor de inserciones en el montículo M. Al algoritmo lo vamos a denominar CPC_Monticulo_MINMAXDIST_MINMINDIST y el paso CPCM2 respecto del algoritmo CPC_Monticulo_MINMINDIST ahora debería ser:

CPCM2 Si se accede a un par de nodos internos (nP y nQ), calcular el mínimo MinMaxDist(RPi, RQj) para cada posible par de MBRs (RPi, RQj), y si es menor que parMasCercano.distancia, actualizar parMasCercano.distancia. Calcular MinMinDist(RPi, RQj) para cada posible par de MBRs (RPi, RQj) e insertar en el montículo todos los pares de MBRs (RPi, RQj) que verifiquen: MinMinDist(RPi, RQj) ≤ parMasCercano.distancia.


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(pi.MBR, qj.MBR) ≤ parMasCercano.distancia then 07 M.insertarElemento(MinMinDist(pi.MBR, qj.MBR), pi.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(pi.MBR, qj.MBR) ≤ parMasCercano.distancia then


127

21 M.insertarElemento(MinMinDist(pi.MBR, qj.MBR), pi.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(pi.MBR, qj.MBR); 29 if dist ≤ parMasCercano.distancia then 30 parMasCercano.distancia = dist; 31 parMasCercano.parObjetos = (pi, qj); 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 función 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(pi.MBR, qj.MBR) < parMasCercano.distancia then 04 parMasCercano.distancia = MinMaxDist(pi.MBR, qj.MBR); 05 endif 06 enddo 07 enddo

4.5.3 Algoritmo branch-and-bound iterativo MINMAXDIST_MINMINDIST Ordenado utilizando un montículo

Al igual que ocurría con CPC_Recursivo_MINMAXDIST_MINMINDIST_Ordenado, una posible mejora para la versión iterativa de CPC_Monticulo_MINMAXDIST_MINMINDIST podría ser ordenar a nivel local los pares de MBRs (RPi, RQj) generados de la combinación dos nodos internos en orden ascendente de MinMinDist(RPi, RQj), e insertar en el montículo según 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 quedaría de la siguiente forma:

Capítulo 4

128

CPCM2 Si se accede a un par de nodos internos (nP y nQ), calcular el mínimo MinMaxDist(RPi, RQj) para cada posible par de MBRs (RPi, RQj), y si es menor que parMasCercano.distancia, actualizar parMasCercano.distancia. Calcular MinMinDist(RPi, RQj) y ordenar todos los posibles pares de MBRs (RPi, RQj) en orden ascendente de MinMinDist(RPi, RQj). Siguiendo este orden, insertar en el montículo todos los pares de MBRs (RPi, RQj) que verifiquen: MinMinDist(RPi, RQj) ≤ parMasCercano.distancia.


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(pi.MBR, qj.MBR); 17 if dist ≤ parMasCercano.distancia then 18 parMasCercano.distancia = dist; 19 parMasCercano.parObjetos = (pi, qj); 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 función 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(pi.MBR, qj.MBR); 07 LMMD[t].direccion_nP = pi.direccion; 08 LMMD[t].direccion_nQ = qj.direccion; 09 if MinMaxDist(pi.MBR, qj.MBR) < parMasCercano.distancia then 10 parMasCercano.distancia = MinMaxDist(pi.MBR, qj.MBR);


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 montículo podemos llevar a cabo el tratamiento sobre pares de MBRs que tengan el mismo valor MinMinDist(RPi, RQj), tanto a nivel global sobre el montículo mínimo 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 cuál es el mejor criterio a aplicar, siempre y cuando el tiempo de respuesta del algoritmo no se vea afectado notablemente.

Al igual que ocurría con CPC_Recursivo_MINMAXDIST_MINMINDIST_Ordenado_M podemos organizar LMMD como un montículo mínimo local que utiliza como clave de ordenación a MinMinDist(RPi, RQj), dando lugar a CPC_Monticulo_MINMAXDIST_MINMINDIST_Ordenado_M. Por tanto, la función 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(pi.MBR, qj.MBR), pi.direccion, q j.direccion); 06 if MinMaxDist(pi.MBR, qj.MBR) < parMasCercano.distancia then 07 parMasCercano.distancia = MinMaxDist(pi.MBR, qj.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();

Capítulo 4

130

4.5.4 Algoritmo branch-and-bound iterativo utilizando la técnica de Barrido del Plano y un montículo

La última mejora del algoritmo iterativo utilizando un montículo para encontrar el par más cercano es aplicar la técnica 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 después barrer el plano de izquierda a derecha sobre uno de los ejes (eje de barrido). La aplicación de esta técnica sobre el algoritmo CPC_Monticulo_MINMINDIST es muy similar a la vista en CPC_Recursivo_Barrido_Plano en la versión recursiva. Por ello, a esta variante la llamamos CPC_Monticulo_Barrido_Plano y el paso CPCM2 respecto del algoritmo CPC_Monticulo_MINMINDIST debería ser:

CPCM2 Si se accede a un par de nodos internos(nP y nQ), ordenar ambos nodos según los criterios del eje y dirección 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 montículo todos los pares de MBRs (RPi, RQj) que verifiquen las dos siguientes condiciones: MinMinDist(RPi, RQj, ejeBarrido) ≤ parMasCercano.distancia y MinMinDist(RPi, RQj) ≤ parMasCercano.distancia (donde RPi o RQj 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.


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(pi.MBR, qj.MBR); 15 if dist ≤ parMasCercano.distancia then 16 parMasCercano.distancia = dist; 17 parMasCercano.parObjetos = (pi, qj); 18 endif 19 enddo 20 enddo 21 endif 22 else 23 M.hacerVacio();


131

24 endif 25 enddo 26 M.destruirMonticulo(); 27 return parMasCercano;

donde la función 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.qk.MBR, ejeBarrido) ≤ parMasCercano.distancia then 10 if MinMinDist(nP.p i.MBR, nQ.qk.MBR) ≤ parMasCercano.distancia then 11 M.insertarElemento(MinMinDist(nP.p i.MBR, nQ.qk.MBR), nP.pi.direccion, nQ.qk.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.pk.MBR, nQ.q j.MBR, ejeBarrido) ≤ parMasCercano.distancia then 23 if MinMinDist(nP.pk.MBR, nQ.q j.MBR) ≤ parMasCercano.distancia then 24 M.insertarElemento(MinMinDist(nP.pk.MBR, nQ.q j.MBR), nP.pk.direccion, nQ.qj.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 (líneas 12-20), en lugar de combinar todas las entradas de un nodo hoja del R*-tree RP (nP) con todas las entradas de un nodo hoja del R*-tree RQ (nQ), se puede aplicar también la técnica de Barrido del Plano descartando posibles pares según MinMinDist sólo sobre ejeBarrido.

Capítulo 4

132

4.5.5 Algoritmo branch-and-bound iterativo basado en un recorrido en anchura y utilizando una lista de montículos

La estructura de datos principal para la implementación de la versión iterativa del algoritmo que obtiene el par más cercano siguiendo un recorrido en anchura es una lista de montículos mínimos por niveles basada en la altura de los R*-trees (Figura 4.9). Los elementos de cada montículo mínimo están formados por un par de MBRs, uno de cada índice espacial R*-tree de entrada, RP y RQ. En realidad esta nueva estructura consiste en dividir el montículo global de los algoritmos iterativos anteriores en una lista de montículos por niveles. El procesamiento de esta nueva estructura de datos se hace nivel a nivel, con la condición de que para procesar el montículo del nivel siguiente, el montículo del nivel actual debe estar completamente vacío o la distancia del par de MBRs situado en la raíz del montículo mínimo en el nivel actual es estrictamente mayor que parMasCercano.distancia.

Altura – 1

LIS

TA

MO

NT

ICU

LO

S Altura – 2

Altura – 3

...

1

0 Ningún montículo

Maltura -1

Maltura -2

Maltura -3

M1

...

Figura 4.9 Estructura de una lista de montículos mínimos 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 más cercano pero no se insertan en el montículo de nivel 0, el cual permanecerá siempre vacío. Por tanto, los pares que se almacenan en la lista de montículos 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 continuación vamos a combinar todos los MBRs de un nodo de RP con todos los MBRs de un nodo de RQ. Aunque también se pueden aplicar las mismas mejoras incorporadas en los anteriores algoritmos, como puede ser la de Barrido del Plano [PrS85].

Al igual que ocurría con los algoritmos que siguen un recorrido en profundidad (recursivo) o basado en una función de selección de primero el mejor (iterativo utilizando un montículo


133

mínimo global), las versiones CPC_Anchura_Fuerza_Bruta y CPC_Anchura_MINMINDIST son casos particulares de CPC_Anchura_MINMAXDIST_MINMINDIST. La descripción por pasos (CPCA#) de este último algoritmo para dos R*-trees con las mismas alturas (altura = AlturaP = AlturaQ) es la que se indica a continuación:

CPCA1 Comenzar desde las raíces de los dos R*-trees, fijar la distancia del par más cercano encontrado hasta el momento, parMasCercano.distancia, a infinito (∞), nivel_actual = altura – 1 y crear la lista de montículos por niveles.

CPCA2 Si se accede a un par de nodos internos (nP y nQ), siendo nivel_actual ≠ 0, calcular el mínimo MinMaxDist(RPi, RQj) para cada posible par de MBRs (RPi, RQj), y si es menor que parMasCercano.distancia, actualizar parMasCercano.distancia. Calcular MinMinDist(RPi, RQj) para cada posible par de MBRs (RPi, RQj) e insertar en el montículo de la lista correspondiente al nivel siguiente al actual (nivel_actual – 1) todos los posibles pares de MBRs (RPi, RQj) 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 montículo de nivel_actual no está vacío y MinMinDist del par situado en la raíz del montículo 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 montículos de la lista están vacíos, entonces parar. En caso contrario, nivel_actual = nivel_actual – 1 y obtener el par situado en la raíz del montículo del nuevo nivel_actual, repitiendo el algoritmo desde CPCA2 para dicho par.


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 pi de RaizP do 05 for every entrada qj de RaizQ do

06 if MinMinDist(pi.MBR, qj.MBR) ≤ parMasCercano.distancia then 07 LM.insertarElemento(AlturaP – 1, MinMinDist(pi.MBR, qj.MBR), pi.direccion, qj.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

Capítulo 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(pi.MBR, qj.MBR) ≤ parMasCercano.distancia then 23 LM.insertarElemento(nivel_actual – 1, MinMinDist(pi.MBR, qj.MBR), pi.direccion, qj.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(pi.MBR, qi.MBR); 31 if dist ≤ parMasCercano.distancia then 32 parMasCercano.distancia = dist; 33 parMasCercano.parObjetos = (pi, qj); 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 versión recursiva (siguiendo un patrón de recorrido en profundidad) y en la que hemos utilizado un montículo mínimo global (recorrido basado en una función de selección de primero el mejor), en esta nueva alternativa basada en un recorrido en anchura, podemos aplicar de igual forma las mismas técnicas de optimización: ordenar todos los pares de MBRs formados por la combinación de dos nodos internos según su MinMinDist y la técnica de Barrido del Plano [PrS85]. La aplicación de estas dos técnicas daría 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 líneas 20-26 deberíamos llamar a la función insertarMonticuloParesOrdenados(LM, nivel, nP, nQ, parMasCercano). Si deseamos obtener el algoritmo CPC_Anchura_MINMAXDIST_MINMINDIST_Ordenado_M, debemos llamar a la función insertarMonticuloParesOrdenados_M(LM, nivel, nP, nQ, parMasCercano). Por último, si nuestro objetivo es conseguir la variante CPC_Anchura_Barrido_Plano, debemos invocar a la función insertarMonticuloParesBarridoPlano(LM, nivel, nP, nQ, parMasCercano).


135

Además, debemos destacar que durante la ejecución del algoritmo, al extraer el par situado en la raíz del montículo en un nivel determinado (que es el que tiene el mínimo valor de MinMinDist(RPi, RQj) hasta el momento), puede haber más de un par con el mismo valor de clave de ordenación (MinMinDist). Por tanto, podemos aplicar los mismos ocho criterios establecidos en CPC_Recursivo_MINMAXDIST_MINMINDIST_Ordenado para el tratamiento de empates sobre los montículos en cada nivel.

Al igual que ocurría con la versión iterativa que utiliza un montículo a nivel global (recorrido basado en una función de selección 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(RPi, RQj) igual a 0 y que estén almacenados y distribuidos en los montículos por niveles durante la ejecución del algoritmo. Esta situación puede provocar que el algoritmo sea más lento al devolver los resultados. Por consiguiente, se hace necesario buscar un compromiso entre el tratamiento de pares con el mismo valor de MinMinDist(RPi, RQj) sobre los montículos 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 más 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 más cercanos utilizando R*-trees como método de indexación. En [HjS98] se presenta un algoritmo incremental e iterativo para resolver el Join Basado en Distancias. Una aplicación directa de esta operación es encontrar los K pares más cercanos almacenados en dos índices arbóreos multidimensionales basados en MBRs (rectángulos minimales), donde el par más 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], además 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 técnicas como la “expansión bidireccional” de los nodos (Simultaneous en [HjS98]) y el Barrido del Plano [PrS85]. También, optimiza la técnica de Barrido del Plano introduciendo los conceptos de eje y dirección de barrido. Además, 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 más cercano se plantea también como un caso particular de K (K = 1).

Nosotros planteamos la consulta del par más cercano como un caso especial caracterizado por la métrica MinMaxDist entre MBRs, y no como la aplicación del algoritmo para un caso particular de K (K = 1). Aunque, como veremos más adelante, al tratar la extensión para determinar el algoritmo que devuelva como resultado los K pares más cercanos, podemos obtener el par más cercano (K = 1) sin utilizar MinMaxDist y sí utilizando MaxMaxDist.

Capítulo 4

136

En [HJS98, SML00] para realizar la operación de join basado en distancias incremental que determina el par más cercano, utilizan como núcleo para su funcionamiento una cola de prioridad (implementada como un montículo), donde cada elemento es un par formado por un componente del R*-tree RP y otro del R*-tree RQ. Por este motivo, vamos a establecer una comparativa con nuestros algoritmos iterativos basados en un montículo mínimo global o en una lista de montículos mínimos para la determinación del par más cercano, en base a una serie de parámetros representativos y que mostramos en la siguiente tabla.

Parámetro Algoritmos de [HjS98, SML00] Algoritmos branch-and-bound basados en montículos

Forma de ejecución 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 finalización 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 finalización, puede que los K pares obtenidos hasta ese momento no sean los más cercanos. Si obtenemos los K pares más cercanos y deseamos obtener los K+1, debemos ejecutar el algoritmo desde el principio.

Tipo de algoritmo branch-and-bound

Recorrido basado en función de selección de primero el mejor (mínima distancia entre objetos).

Recorrido basado en una función de selección de primero el mejor (MinMinDist), utilizando un montículo mínimo global. Recorrido en anchura, caracterizado por una lista de montículos por niveles.

Estructura del montículo Esquema híbrido Memoria/Disco. Montículo almacenado en memoria. Tipo de pares insertados en el montículo

MBR/MBR, MBR/OBJ, OBJ/MBR y OBJ/OBJ.

MBR/MBR.

Tratamiento de empates en el montículo

[HjS98]: dos políticas para el tratamiento de empates.

Varias políticas para dicho tratamiento (8), además de no considerar ningún tratamiento.

Recorrido de los R*-trees [HjS98]: tres políticas para recorrer los R*-trees (Basic, Even y Simultaneous). [SML00]: sólo una (bidireccional), que es equivalente a la política Simultaneous de [HjS98].

Sólo una política, recorrido simultáneo de ambos R*-trees, sin dar prioridad a ninguno de los árboles.

Cota superior para el cálculo del par más cercano

[HjS98]: calcula y actualiza Dmax utilizando una cola de prioridad extra junto con una tabla hash. [SML00]: además de las propuestas hechas en [HjS98] utiliza otra cola de prioridad para aplicar una estrategia de poda más agresiva actualizando Emax y Dmax.

parMasCercano.distancia se actualiza en función del mínimo valor de MinMaxDist cuando se procesan pares de MBRs en nodos internos (regla de poda 2).

Procesar el algoritmo hasta que ...

El montículo esté vacío o el par más cercano se ha obtenido.

El montículo esté vacío o el valor de MinMinDist del par situado en la raíz del montículo sea mayor que parMasCercano.distancia. La lista de montículos esté vacía o el valor de MinMinDist del par situado en la raíz de todos los montículos sea mayor que parMasCercano.distancia.


137

Tratamiento de la consulta del par más cercano

Caso particular de K (K = 1). Caso especial caracterizado por la métrica MinMaxDist. Aunque también puede considerarse como un caso particular de K-CPC (K = 1), como veremos en el siguiente capítulo.

Tamaño de la página en los experimentos

[HjS98]: 1 Kbyte. [SML00]: 4 Kbytes.

1 Kbyte.

Tipo y dimensionalidad de los objetos utilizados en los experimentos

Puntos [HjS98] y líneas [SML00] en E(2).

Puntos en E(2).

Tabla 4.1 Comparativa entre algoritmos iterativos, incrementales y no incrementales para obtener el par más cercano utilizando R*-trees como método de indexación.

4.7 Conclusiones

Branch-and-bound es una técnica para el diseño de algoritmos que pretenden encontrar la solución óptima de un determinado problema. La idea principal consiste en descomponer el problema inicial en un número finito de subproblemas de tamaño más pequeño, calculando cotas relativas a dichos subproblemas con el objetivo de limitar el número de soluciones posibles a examinar. Dicho proceso de descomposición se aplica repetidamente a los subproblemas generados, resolviéndolos o podándolos hasta que se encuentra la solución óptima o se determina que el problema no se puede resolver. En nuestro caso utilizaremos la técnica branch-and-bound para encontrar el par más cercano de dos conjuntos de objetos almacenados en sendos R*-trees, ya que es la más apropiada al aplicarla sobre índices arbóreos.

Para diseñar algoritmos branch-and-bound eficientes que den solución a las consultas de los pares más cercanos debemos tener en cuenta los siguientes aspectos:

1. Aplicación de diferentes estrategias de búsqueda (formas de procesar la consulta según el recorrido de los índices que intervienen en ella). Nosotros hemos propuesto para resolver nuestro problema: búsqueda en profundidad, búsqueda de primero el mejor y búsqueda en anchura combinada con primero el mejor. Para la primera utilizamos la recursividad que proporcionan la mayoría de los lenguajes de programación, mientras que para las otras dos utilizaremos los montículos como estructura de datos principal más apropiada para la implementación iterativa sin hacer uso de la recursividad.

2. Definición de heurísticas de poda que se aplicarán en algoritmos branch-and-bound sobre R*-trees. Dichas reglas de poda se basan en las métricas y propiedades entre pares de MBRs definidas en el capítulo anterior (MinMinDist, MinMaxDist y MaxMaxDist).

3. Aplicación de técnicas que optimicen los algoritmos branch-and-bound diseñados para la consulta en cuestión, con el objetivo de reducir el número de accesos a disco y el tiempo de respuesta. Entre estas técnicas destacamos el barrido del plano adaptado a nuestro problema.

Capítulo 4

138

En este capítulo, también hemos establecido una comparativa con otros algoritmos que determinan el par más cercano utilizando R*-trees [HjS98, SML00], fijando diferentes parámetros para su caracterización. En ella aclaramos las principales similitudes y diferencias de los algoritmos iterativos (basados en montículos) que presentamos en esta tesis con los publicados anteriormente en esta línea de investigación.

Una vez estudiados los algoritmos branch-and-bound sobre índices arbóreos basados en MBRs para la consulta del par más cercano, determinar el más eficiente de ellos, requiere un laborioso y serio trabajo de implementación, análisis y evaluación. Todo ello se realizará en el capítulo dedicado a la implementación, donde compararemos minuciosamente las alternativas propuestas en este capítulo sobre conjuntos de datos reales indexados en R*-trees.

139

Capítulo 5

EXTENSIONES DE LOS ALGORITMOS Y DETALLES DE

IMPLEMENTACIÓN

5.1 Introducción

Al igual que sucede con otras consultas basadas en distancias sobre métodos de indexación, tales como la consulta en rango y la del vecino más próximo, es preciso extender la consulta del par más cercano para poder aplicarla a otros casos más específicos o más generales. Por ejemplo, un usuario desea conocer los 15 pares (centros turísticos, hoteles) con menor distancia entre ellos, por tanto, es necesario diseñar un algoritmo que encuentre los K pares más cercanos y los devuelva en orden ascendente de distancia. También es necesario poder procesar R*-trees con diferentes alturas, puesto que se pueden indexar conjuntos de elementos muy grandes y combinarse con otros más pequeños. Por ejemplo, una consulta posible sería encontrar los K pares (núcleos de población, pantanos) más cercanos que existen en todo el territorio nacional, teniendo para “núcleos de población” un gran número de elementos, mientras que para “pantanos” el número es mucho menor. Otra extensión natural a nuestra consulta en estudio sería aquella que no sólo encuentra los K pares más 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 (almacén, tienda) que se encuentran a menos de 5 kilómetros.

Las extensiones y casos de estudio presentados en este capítulo pretenden demostrar la gran operatividad que pueden proporcionar los algoritmos estudiados en el capítulo anterior. La primera de estas extensiones es la que hace posible realizar la consulta sobre R*-trees con diferentes alturas, presentándose para ello dos interesantes técnicas. A continuación, se

Capítulo 5

140

propone cómo realizar la consulta del par más cercano para el caso en que los objetos no están 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 representación exacta de los objetos. Después se presenta cómo extender los algoritmos de la consulta del par más cercano analizados en el capítulo anterior para dar solución a la consulta de los K pares más cercanos, siendo esta extensión la más interesante y de gran aplicación. Otra posible extensión que se plantea es obtener todos o los K pares más cercanos que tienen una distancia en un rango dado a priori [Dist_Min, Dist_Max]. Otro caso para el estudio sería realizar la operación inversa, es decir, encontrar el par más lejano o los K pares más lejanos de dos conjuntos de objetos almacenados en sendos R*-trees. Por último, se plantean también dos operaciones que son consecuencia inmediata de la consulta del par más cercano o de los K pares más cercanos: la Auto-consulta y la Semi-consulta de los pares más cercanos. La Auto-consulta de los pares más cercanos consiste en combinar un conjunto de objetos de entrada indexados en un R*-tree consigo mismo (RP ≡ RQ), para determinar cuáles son los objetos más cercanos entre sí. Por otro lado, la Semi-consulta de los pares más cercanos calcula para cada objeto indexado en el R*-tree RP el objeto más próximo indexado en el R*-tree RQ.

5.2 Tratamientos para R*-trees con diferentes alturas

Una vez estudiados todos los algoritmos branch-and-bound para resolver la consulta del par más 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 ramificación m y M (manteniéndose igual la cardinalidad de los conjuntos de datos a indexar), y por otro lado, diferente número de objetos a indexar en los R*-trees (permaneciendo idénticos los factores de ramificación). Por este motivo, estos parámetros son muy importantes en la construcción de los R*-trees para luego realizar consultas sobre ellos.

RP

RQ

RP RQ

(c)

(b)

RP

RQ

(d)

RP RQ

(a)

Figura 5.1 Posibles casos para dos R*-trees (RP y RQ) con diferentes alturas.

Extensiones de los algoritmos y detalles de implementación

141

En la Figura 5.1 se muestran los cuatro posibles casos que se pueden presentar con dos R*-trees (RP y RQ) que tengan diferentes alturas, y que deben ser considerados en la implementación de los algoritmos.

Intuitivamente, la primera aproximación que pensamos cuando deseamos encontrar el par más 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 solución podría 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 más próximo (CVP) sobre un subárbol 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 más próximos de cada uno de los objetos del R*-tree de menor altura obtenemos el mínimo de ellos como el par más cercano. Evidentemente esta misma técnica 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 técnicas, cuyas descripciones para los algoritmos recursivos son la que se muestran a continuación:

• La primera técnica se denomina fijar la raíz (Figuras 5.1.a y 5.1.c). La idea de esta técnica consiste en que cuando se llama recursivamente al algoritmo con un par de nodos internos con diferentes niveles, se detiene la propagación en el R*-tree del nodo con nivel más bajo, mientras la propagación en el otro árbol continúa, hasta que se llegue a un par de nodos internos con el mismo nivel. Entonces, la propagación hacia abajo en ambos subárboles continua con normalidad igual que si tuviesen la misma altura.

• La segunda técnica 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 propagación en el árbol del nodo hoja, mientras que la propagación en el otro árbol continua normalmente.

La aplicación de la estrategia fijar la raíz 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 mínimo MinMaxDist(RPi, RQj) para cada posible par de MBRs (RPi, RQj), formado por un MBR contenido en el nodo de nivel más alto y el MBR del nodo de nivel más bajo. Si este mínimo es menor que parMasCercano.distancia, actualizar parMasCercano.distancia. Calcular para todos estos pares, MinMinDist(RPi, RQj). Para cada par con MinMinDist(RPi, RQj) ≤ parMasCercano.distancia, hacer una llamada recursiva teniendo como parámetros los nodos correspondientes a los MBRs del par, con la restricción de que un parámetro será el nodo que reside en el nivel más bajo (nodo raíz del

Capítulo 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 aplicación 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 mínimo MinMaxDist(RPi, RQj) para cada posible par de MBRs (RPi, RQj) formado por el MBR del nodo hoja y un MBR del nodo interno. Si este mínimo es menor que parMasCercano.distancia, actualizar parMasCercano.distancia. Calcular para todos estos pares, MinMinDist(RPi, RQj). Para cada par con MinMinDist(RPi, RQj) ≤ parMasCercano.distancia, hacer una llamada recursiva teniendo como parámetros los nodos correspondientes a los MBRs del par, con la restricción de que un parámetro 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 continuación el seudo-código del algoritmo CPC_Recusivo_MINMAXDIST_MINMINDIST siguiendo una política 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(pi.MBR, qj.MBR) ≤ parMasCercano.distancia then 06 nP’ = LeerNodo(pi.direccion); 07 nQ’ = LeerNodo(qi.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(pi.MBR, MBRNodoHoja) ≤ parMasCercano.distancia then 18 nP’ = LeerNodo(pi.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(qi.direccion); 29 CPC_Recursivo_MINMAXDIST_MINMINDIST(nP, nQ’, parMasCercano); 30 endif 31 enddo 32 endif 33 if nP and nQ son nodos HOJA then


143

34 for every entrada p i de nP do 35 for every entrada q j de nQ do 36 dist = MinMinDist(pi.MBR, qj.MBR); 37 if dist ≤ parMasCercano.distancia then 38 parMasCercano.distancia = dist; 39 parMasCercano.parObjetos = (pi, qj); 40 endif 41 enddo 42 enddo 43 endif 44 endif

donde la función 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(ni.MBR, MBRParametro) < parMasCercano.distancia then 03 parMasCercano.distancia = MinMaxtDist(ni.MBR, MBRParametro); 04 endif 05 enddo

La característica más 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. También es importante observar cómo se aplica la técnica fijar las hojas en la implementación del algoritmo (líneas 13-22 para interno/hoja y líneas 23-32 para hoja/interno). Esta aproximación se lleva a cabo obteniendo el MBR del nodo hoja y combinándolo con los MBRs del nodo interno, generando pares de la forma MBR/MBR. Además, para realizar la llamada recursiva con pares interno/hoja y hoja/interno, sólo 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 más cercano se realiza de la misma forma que si los dos R*-trees tuvieran la misma altura, tal y como hemos estudiado en el capítulo anterior.

Para los algoritmos iterativos que utilizan un montículo mínimo global y su recorrido está basado en una función de selección de primero el mejor pueden modificarse fácilmente para procesar R*-trees con diferentes alturas utilizando las estrategias de fijar las hojas o fijar la raíz. El paso adicional que es necesario añadir a estos algoritmos es totalmente análogo a cada uno de los pasos indicados anteriormente, dependiendo de la técnica utilizada. La única diferencia es que se sustituye la llamada recursiva por una inserción del par en el montículo.

A continuación, vamos a mostrar el seudo-código del algoritmo iterativo utilizando un montículo mínimo global con una estrategia de búsqueda basada en una función de selección de primero el mejor, CPC_Monticulo_MINMAXDIST_MINMINDIST siguiendo una política de fijar la raíz.

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);

Capítulo 5

144

07 for every entrada p i de RaizP do 08 for every entrada q j de RaizQ do 09 if MinMinDist(pi.MBR, qj.MBR) ≤ parMasCercano.distancia then 10 M.insertarElemento(MinMinDist(pi.MBR, qj.MBR), pi.direccion, AlturaP – 1, qj.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.dirección_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(pi.MBR, qj.MBR) ≤ parMasCercano.distancia then 27 M.insertarElemento(MinMinDist(pi.MBR, qj.MBR), pi.direccion, Elem.nivel_nP – 1, qj.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(pi.MBR, qj.MBR); 36 if dist ≤ parMasCercano.distancia then 37 parMasCercano.distancia = dist; 38 parMasCercano.parObjetos = (pi, qj); 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 función Procesar_Mayor_Arbol viene dada por el seudo-código 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(pi.MBR, MBRNodoHoja) ≤ parMasCercano.distancia then


145

06 M.insertarElemento(MinMinDist(pi.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, qj.MBR), nP.direccion, Altura_nP, qj.direccion, Altura_nQ – 1); 15 endif 16 enddo 17 endif

En este algoritmo cuyo recorrido está basado en una función de selección de primero el mejor y los pares se almacenan en un montículo mínimo global, podemos comprobar la manera de aplicar la técnica fijar la raíz y el tratamiento de tipos de pares de nodos (interno/interno, interno/hoja, hoja/interno y hoja/hoja). La técnica de fijar la raíz consiste en fijar la altura del R*-tree más pequeño y reducir la del mayor hasta que ambos tienen la misma altura, para después 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 versión recursiva, solo que se inserta un par en el montículo en lugar de realizar una llamada recursiva.

De igual forma pueden modificarse fácilmente los algoritmos que utilizan una lista de montículos mínimos organizada por niveles (función de selección 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 raíz. El paso adicional que es necesario añadir a estos algoritmos es totalmente análogo a cada uno de los pasos indicados anteriormente. La única diferencia con respecto a los que utilizan un montículo mínimo global es que se sustituye inserción del par en el montículo por la inserción del par en la lista de montículos mínimos dependiendo del nivel que se esté procesando.

A continuación, vamos a mostrar el seudo-código del algoritmo iterativo basado en un recorrido en anchura utilizando una lista de montículos mínimos organizada por niveles (estrategia de búsqueda basada en una función de selección de primero el mejor en cada uno de ellos) CPC_Anchura_MINMAXDIST_MINMINDIST siguiendo una política 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(pi.MBR, qj.MBR) ≤ parMasCercano.distancia then 08 LM.insertarElemento(maxima_Altura – 1, MinMinDist(pi.MBR, qj.MBR), pi.direccion, qj.direccion); 09 endif 10 enddo 11 enddo

Capítulo 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(pi.MBR, qj.MBR) ≤ parMasCercano.distancia then 26 LM.insertarElemento(nivel_actual – 1, MinMinDist(pi.MBR, qj.MBR), pi.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 pi de nP do

35 if MinMinDist(pi.MBR, MBRNodoHoja) ≤ parMasCercano.distancia then 36 LM.insertarElemento(nivel_actual – 1, MinMinDist(pi.MBR, MBRNodoHoja), pi.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 qj 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(pi.MBR, qj.MBR); 53 if dist ≤ parMasCercano.distancia then 54 parMasCercano.distancia = dist; 55 parMasCercano.parObjetos = (pi, qj); 56 endif 57 enddo 58 enddo 59 endif 60 else 61 LM.hacerVacio(nivel_actual); 62 endif 63 enddo


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 número de niveles de la lista de montículos mínimos va a coincidir con la altura del mayor R*-tree. En este algoritmo aplicamos la técnica 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 montículos mínimos organizada por niveles. El algoritmo desciende por los dos árboles hasta que el más pequeño se encuentra en el nivel anterior a las hojas, continuando posteriormente por el más grande hasta que ambos se encuentran en el mismo nivel, procesando todas las entradas de las hojas de forma simultánea.

5.3 Extensión 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) están almacenados en las hojas de los R*-trees (punteros nulos), dando lugar al modelo de organización primario, tal y como se muestra en la Figura 5.2.a. Pero también, se puede dar el caso de que las aproximaciones (MBRs) y los punteros a las representaciones exactas de los objetos estén almacenados en las hojas de los R*-trees, estando guardados los objetos en archivos externos al método de acceso, por ejemplo en un archivo de acceso directo. A este último le llamamos modelo de organización 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 organización primario, o en archivos externos donde estaría guardada la geometría exacta de los objetos espaciales siguiendo un modelo de organización secundario.

Capítulo 5

148

(b) (a)

R*-tree R*-tree

···

... ...

Figura 5.2 Modelos de organización para almacenar objetos en un R*-tree según [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 descripción exacta de los mismos, la cual se encuentra almacenada en otro archivo, entonces tendríamos 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 (pi, qj) es un par de objetos (MBRs o puntos) con punteros nulos then 04 dist = MinMinDist(pi.MBR, qj.MBR); 05 if (dist ≤ parMasCercano.distancia) then 06 parMasCercano.distancia = dist; 07 parMasCercano.parObjetos = (pi, qj); 08 endif 09 else 10 if (pi, qj) es un par de MBRs, cuyos punteros asociados apuntan a un par de objetos then 11 if MinMinDist(pi.MBR, qj.MBR) ≤ parMasCercano.distancia then 12 Oi = LeerObjetoArchivoExterno(pi.direccion) 13 Oj = LeerObjetoArchivoExterno(qj.direccion) 14 D = MinimaDistanciaEntreObjetos(Oi, Oj); 15 if (D ≤ parMasCercano.distancia) then 16 parMasCercano.distancia = D; 17 parMasCercano.parObjetos = (Oi, Oj); 18 endif 19 endif 20 endif 21 endif 22 enddo 23 enddo

En este fragmento de código podemos observar que las líneas 03-09 son las mismas que hemos incluido en los algoritmos previamente estudiados, pero en las líneas 10-18 debemos cargar en memoria la descripción exacta de los dos objetos en cuestión, calcular la mínima distancia entre ellos (MinimaDistanciaEntreObjetos) según algoritmos de geometría computacional, para luego compararla con la distancia del par de objetos más cercano encontrado hasta el momento. El cálculo de MinimaDistanciaEntreObjetos(Oi, Oj) se puede


149

llevar a cabo utilizando los algoritmos propuestos en [ChW83, ChW84, Ede85] si dichos objetos son polígonos convexos, o en [GJK88, LiC91] si son objetos convexos.

5.4 Extensión de los algoritmos para la consulta de los K pares más cercanos

Hasta ahora sólo hemos considerado los algoritmos para dar solución a la consulta del par más cercano, en este apartado vamos a proponer extensiones sobre esos algoritmos para la consulta de los K pares más cercanos.

Para obtener los K pares más cercanos (K-CPC, caso general del par más cercano) de forma no incremental debemos mantener una estructura de datos adicional a nivel global en la que estén almacenados los K pares más cercanos encontrados hasta el momento, y el mecanismo de poda de MBRs se debería llevar a cabo según la distancia del par más lejano de los K pares más cercanos almacenados hasta el momento en dicha estructura de datos adicional. Es importante indicar que esta estructura de datos es un montículo de K pares en el que la distancia mayor es la del par situado en la raíz (montículo máximo), 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 mínimo 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 solución a la consulta de los K pares más cercanos. Esta variable tiene la misma funcionalidad que parMasCercano.distancia, debiendo estar inicializada a infinito (∞).

distanciaPodaKCPC

R*-tree RP R*-tree RQ K-CPC

KMasCercanos (global)

KMasCercanos.obtenerMaximo().distancia

LISTAMxMxD (local)

Figura 5.3 Estructuras de datos adicionales para el procesamiento de los K pares más

cercanos (K-CPC) sobre algoritmos recursivos.

Capítulo 5

150

Las métricas MinMinDist(R1, R2) y MaxMaxDist(R1, R2), definidas en el capítulo 3 se utilizan en dos reglas básicas que se aplican para realizar el proceso de poda en los nodos de los R*-trees cuando se recorren desde la raíz hasta las hojas según algoritmos branch-and-bound para encontrar los K pares más cercanos. Las reglas son las siguientes:

1. Por el teorema 3.4. Si KMasCercanos.obtenerMaximo().distancia es la distancia Euclídea del par más lejano de los K pares más cercanos encontrados hasta el momento y coincide con distanciaPodaKCPC, entonces todos los pares de MBRs (RPi, RQj) tal que RPi ∈ RP y RQj ∈ RQ, con distancia MinMinDist(RPi, RQj) estrictamente mayor que KMasCercanos.obtenerMaximo().distancia pueden descartarse, ya que estos pares de MBRs no incluirán 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 más 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 ramificación 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 técnica más complicada utilizando estructuras de datos adicionales a nivel global como veremos más adelante) de ambos R*-trees de la siguiente forma:

2.1. Calcular MaxMaxDist(RPi, RQj) para cada par de MBRs que se pueden formar de la combinación de dos nodos (nP y nQ) de dichos R*-trees y almacenarlos todos (RPi, RQj, MaxMaxDist(RPi, RQj)) en una lista temporal auxiliar a nivel local que denominaremos LISTAMxMxD.

2.2. Todos los pares de MBRs (RPi, RQj) tal que RPi ∈ RP y RQj ∈ RQ, de la lista temporal LISTAMxMxD se ordenan ascendentemente en base a su valor de MaxMaxDist(RPi, RQj). El método de ordenación utilizado es MergeSort, igual que ocurría con LISTAMINMINDIST en CPC_Recursivo_MINMAXDIST_MINMINDIST_Ordenado.

2.3. Sabiendo que el número mínimo de objetos almacenados en los nodos hoja que se pueden generar de cada par de MBRs (RPi, RQj) situados en nodos internos en ambos R*-trees viene dado por la expresión siguiente:

( ) ( ) ( )jQiP

ji

RnivelQ

RnivelPQP mmRRX ×=,

Entonces, podemos determinar el i-ésimo elemento de la lista temporal de pares de MBRs, LISTAMxMxD, recorriéndola hasta encontrar el primer elemento que verifique la siguiente condición:

[ ] [ ]( ) KMBRiLISTAMxMxDMBRiLISTAMxMxDXTotal

iQP ≥∑

−

=

1

0

. ,.


151

siendo Total = nP.numeroDeEntradas * nQ.numeroDeEntradas. Entonces podemos descartar todos los pares de MBRs (RPi, RQj) donde RPi ∈ RP y RQj ∈ RQ, tal que MinMinDist(RPi, RQj) > LISTAMxMxD[i].MaxMaxDist, ya que estos pares de MBRs no incluirán otro par de objetos con distancia menor que LISTAMxMxD[i].MaxMaxDist. Además, si distanciaPodaKCPC se corresponde con la distancia Euclídea del par más lejano de los K pares más 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 capítulo 3 se utilizarán 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 más cercanos. A continuación mostramos la extensión 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(pi.MBR, qj.MBR) ≤ distanciaPodaKCPC then 06 nP’ = LeerNodo(pi.direccion); 07 nQ’ = LeerNodo(qi.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(pi.MBR, qj.MBR); 16 if KMasCercanos.estaLleno() then 17 if dist ≤ distanciaPodaKCPC then 18 KMasCercanos.eliminarMaximo(); 19 KMasCercanos.insertarElemento(dist, p i, qj); 20 if KMasCercanos.obtenerMaximo().distancia < distanciaPodaKCPC then 21 distanciaPodaKCPC = KMasCercanos.obtenerMaximo().distancia; 22 endif 23 endif 24 else 25 KMasCercanos.insertarElemento(dist, p i, qj); 26 endif 27 enddo 28 enddo 29 endif

Capítulo 5

152

donde la función 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(pi.MBR, qj.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(mP , nivel(nP)) * potencia(mQ, 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 función potencia(x, y) representa el resultado de realizar la operación xy, y la función nivel(a) indica el nivel del nodo a en un R*-tree determinado.

Es interesante destacar como ocurría en CPC_Recursivo_MINMAXDIST_MINMINDIST_Ordenado_M, que LISTAMxMxD puede organizarse como un montículo mínimo a nivel local utilizando como clave de ordenación MaxMaxDist(pi.MBR, qj.MBR), donde el tiempo empleado para insertar un elemento y eliminar el mínimo está en O(logN) [Seg98], siendo N el número de elementos del montículo (N = nP.numeroDeEntradas * nQ.numeroDeEntradas). Además, organizando LISTAMxMxD como un montículo mínimo evitamos realizar la operación de ordenación (coste de al menos O(N * logN)) en la línea 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 (función actualizarDistanciaPodaKCPC en la línea 02) obtenemos la variante del algoritmo denominada KCPC_Recursivo_MINMINDIST (distanciaPodaKCPC = KMasCercanos.obtenerMaximo().distancia) y que es la extensión de CPC_Recursivo_MINMINDIST. También, 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 más cercanos se realizan de la misma forma que se ha indicado anteriormente, teniendo en cuenta las características particulares de cada uno. Los algoritmos resultantes serían KCPC_Recursivo_MAXMAXDIST_MINMINDIST_Ordenado,


153

KCPC_Recursivo_MAXMAXDIST_MINMINDIST_Ordenado_M y KCPC_Recursivo_Barrido_Plano. Además, las técnicas estudiadas en el apartado 5.2 (fijar la raíz y fijar las hojas) para tratar R*-trees con diferentes alturas también se pueden extender fácilmente a los algoritmos que devuelven los K pares más cercanos.

Para los algoritmos iterativos que utilizan montículos (siguiendo un recorrido basado en una función de selección de primero el mejor o un recorrido en anchura combinado con una estrategia de búsqueda de primero el mejor) se utiliza una técnica más 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 más cercanos, se puede estimar la distancia máxima 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 montículo máximo como los K pares más 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 más cercanos. No obstante, también se puede hacer uso de otros tipos de pares, como los MBR/MBR, para llevar a cabo el proceso de poda.

Si denotamos a MxMxDmax como la distancia máxima impuesta sobre los pares MBR/MBR que se irá actualizando durante el procesamiento del algoritmo, y a MaxMaxDist como la función 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 MxMxDmax (fijada inicialmente a ∞) lo máximo posible, dependiendo del valor de K (número máximo de pares requerido). Un par de MBRs (RPi, RQj) se elige para estimar MxMxDmax si verifica que MaxMaxDist(RPi, RQj) ≤ MxMxDmax, garantizando que todos los pares OBJ/OBJ cubiertos por (RPi, RQj) tendrán una distancia en el rango [0, MxMxDmax].

El proceso para ir actualizando MxMxDmax 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 (RPi, RQj), que incluya cada uno de los pares de MBRs que se han insertado en el montículo mínimo principal pero aún no se han extraído. Este conjunto adicional de pares de MBRs va a ser un montículo máximo a nivel global organizado de tal forma que en la raíz se coloca el par con mayor valor de MaxMaxDist(RPi, RQj), y nosotros vamos a denominar MMMD. Según las definiciones de MxMxDmax y MMMD, podemos deducir que MxMxDmax = MMMD.obtenerMaximo().distancia. Por tanto, las estructuras de datos adicionales necesarias para obtener los K pares más cercanos utilizadas en los algoritmos iterativos son las que se muestran en al Figura 5.4.

Capítulo 5

154

distanciaPodaKCPC

R*-tree RP R*-tree RQ

K-CPC

KMasCercanos OBJ/OBJ (global)


MMMD MBR/MBR (global)

MxMxDmax

Figura 5.4 Estructuras de datos adicionales para el procesamiento de los K pares más

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 combinación de elementos de dos nodos) es el siguiente:

1. Cuando un par de MBRs (RPi, RQj) se inserta en el montículo mínimo inserción, también se inserta en MMMD. Si la inserción 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 MxMxDmax al valor de MaxMaxDist del último par borrado.

2. Cuando un par de MBRs (RPi, RQj) se extrae del montículo principal, debe borrarse también de MMMD, si éste está presente.

Además, como ocurría 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 mínimo valor de aplicar cada una de estas técnicas. A ésta la denominábamos distanciaPodaKCPC y representará el valor de distancia por el cual vamos a realizar la poda en los algoritmos para dar solución a la consulta de los K pares más 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 montículo máximo para localizar de forma directa un par de MBRs determinado según su MaxMaxDist. Esta tabla hash está basada en una función hash de la forma, i = funcion_acceso(clave), que aplicándola a una clave obtenemos un número entero y positivo que nos da la posición del elemento correspondiente dentro de dicha tabla. Para nosotros la


155

clave de acceso se corresponde con el valor de MaxMaxDist entre los MBRs que forman el par. Por tanto, la ecuación de transformación viene dada de la siguiente forma:

Posicion = MaxMaxDist(MBR1, MBR2) mod N

donde N es el tamaño introducido por el usuario para la tabla hash.

La organización de esta tabla hash está basada en una estructura de datos formada por un número 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 posición 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 montículo (array en memoria).

MMMD

···

0

Tabla_Hash

1

2

N – 1

Figura 5.5 Tabla hash organizada por listas enlazadas asociada a un montículo máximo de

pares de MBRs (MMMD), utilizando como clave para la organización de la misma, la métrica MaxMaxDist.

Aplicando las reglas expuestas anteriormente, a continuación mostramos la extensión 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(pi.MBR, qj.MBR) ≤ distanciaPodaKCPC then 09 M.insertarElemento(MinMinDist(pi.MBR, qj.MBR), pi.direccion, p i.MBR, qj.direccion, q j.MBR); 10 MMMD.insertarActualizar(MaxMaxDist(pi.MBR, qj.MBR), AlturaP, p i.MBR, AlturaP, q j.MBR, K, sumaParesPosibles, distanciaPodaKCPC); 11 endif

Capítulo 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(pi.MBR, qj.MBR) ≤ distanciaPodaKCPC then 24 M.insertarElemento(MinMinDist(pi.MBR, qj.MBR), pi.direccion, p i.MBR, qj.direccion, qj.MBR); 25 MMMD.insertarActualizar(MaxMaxDist(pi.MBR, qj.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(pi.MBR, qj.MBR); 33 if KMasCercanos.estaLleno() then 34 if dist ≤ distanciaPodaKCPC then 35 KMasCercanos.eliminarMaximo(); 36 KMasCercanos.insertarElemento(dist, p i, qj); 37 if KMasCercanos.obtenerMaximo ().distancia < distanciaPodaKCPC then 38 distanciaPodaKCPC = KMasCercanos.obtenerMaximo().distancia; 39 endif 40 endif 41 else 42 KMasCercanos.insertarElemento(dist, p i, qj); 43 endif 44 enddo 45 enddo 46 endif 47 else 48 M.hacerVacio(); 49 endif 50 enddo 51 M.destruirMonticulo();

donde la función insertarActualizar asociada al montículo 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(mP , nivel_P) * potencia(mQ, nivel_Q)); 04 auxDmax = distanciaPodaKCPC; 05 intentarActualizarDistanciaPodaKCPC = false; 06 MMMDActualizado = true; 07 while ((not(MMMD.estaVacio())) and (MMMDActualizado)) do 08 MMMDActualizado = false;


157

09 Item1 = MMMD.obtenerMaximo(); 10 auxSumaParesPosibles = sumaParesPosibles – (potencia(mP , Item1.nivel_P) * potencia(mQ, Item1.nivel_Q)); 11 if (auxSumaParesPosibles ≥ K) then 12 Item = MMMD.eliminarMaximo(); 13 Tabla_Hash.eliminarElemento(Item); 14 sumaParesPosibles = sumaParesPosibles – (potencia(mP , Item.nivel_P) * potencia(mQ, 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 función eliminarActualizar asociada también al montículo 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(mP , Item.nivel_P) * potencia(mQ, Item.nivel_Q)); 06 endif

La extensión del algoritmo anterior para las otras variantes que utilizan un montículo según la política de primero el mejor (Ordenado y utilizando la técnica de Barrido del Plano) es inmediata. Al igual ocurre cuando se combinan las técnicas de primero el mejor con un recorrido en anchura, sólo que para este caso se utiliza una lista de montículos mínimos organizada por niveles.

5.5 Extensión de los algoritmos para obtener los K pares más cercanos en un rango de distancia [Dist_Min, Dist_Max]

Otro caso de estudio como extensión de la consulta de los K pares más cercanos que nos podemos plantear es determinar los K pares más 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 mínimo y el máximo 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.

Capítulo 5

158

2. Si se accede a dos nodos internos (nP y nQ), no actualizar distanciaPodaKCPC utilizando MaxMaxDist. Calcular MinMinDist(RPi, RQj) y propagar recursivamente hacia abajo en los dos R*-trees sólo para aquellos pares de MBRs (RPi, RQj) que verifiquen MinMinDist(RPi, RQj) ≤ 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 más cercanos que están dentro de un rango distancia dado a priori [Dist_Min, Dist_Max].

[Dist_Min, Dist_Max]


K-CPC



Figura 5.6 Estructuras de datos adicionales para obtener los K pares más cercanos que

están en un rango de distancia [Dist_Min, Dist_Max].

La estructura de los algoritmos que encuentran la solución buscada son similares a los que determinan los K pares más cercanos. A continuación mostramos la extensión 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(pi.MBR, qj.MBR) ≤ Dist_Max then 05 nP’ = LeerNodo(pi.direccion); 06 nQ’ = LeerNodo(qi.direccion); 07 KCPC_Recursivo_RangoDistancia_MINMINDIST(nP’, nQ’, KMasCercanos, Dist_Min, Dist_Max); 08 endif 09 enddo


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(pi.MBR, qj.MBR); 15 if (Dist_Min ≤ dist) and (dist ≤ Dist_Max) then 16 if KMasCercanos.estaLleno() then 17 if (dist ≤ KMasCercanos.obtenerMaximo().distancia) then 18 KMasCercanos = eliminarMaximo(); 19 KMasCercanos.insertarElemento(dist, p i, qj); 20 endif 21 else 22 KMasCercanos.insertarElemento(dist, p i, qj); 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 tamaño del montículo KMasCercanos también. Entonces, las modificaciones de los algoritmos serán las tres que se han citado anteriormente con una consideración adicional referida a la gestión del montículo 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 tamaño de KMasCercanos puede tener |P|·|Q|, donde |P| y |Q| es el número de objetos P y Q indexados para dar lugar a los R*-trees RP y RQ, respectivamente. Por tanto, no siempre es posible almacenar el montículo KMasCercanos en memoria principal y se deberán utilizar un esquema híbrido memoria/disco utilizando técnicas basadas en la división del rango, como se presentan en [HjS98, SML00].

La extensión a los algoritmos iterativos de estas variantes de la consulta es sencilla, independientemente de que sigan una política de primero el mejor utilizando un montículo o uno que combine las técnicas de primero el mejor con un recorrido en anchura, utilizando para ello un montículo organizado por niveles. Para realizar esto sólo habría que considerar el tratamiento especial que se hace tanto en los nodos internos como en los nodos hoja según el rango de distancia [Dist_Min, Dist_Max] dado como parámetro.

Capítulo 5

160

5.6 Extensión de los algoritmos para realizar la consulta del par más lejano y de los K pares más lejanos

Otra extensión de la consulta del par más cercano (CPC) y de los K pares más cercanos (K-CPC) que nos podemos plantear es determinar el par más lejano (de forma abreviada CPL) y los K pares más lejanos (cuya abreviación sería K-CPL) de dos conjuntos de objetos indexados por sendos R*-trees.

Definición. Consulta del Par más Lejano. CPL. Dados dos conjuntos no vacíos P y Q (P ≠ ∅ y Q ≠ ∅), la consulta del par más lejano se define como el siguiente conjunto:

CPL(P, Q) = {(O, O’) ⊆ P×Q: ∀(Oi, Oj’) ⊆ P×Q – {(O, O’)}, d(O, O’) ≥ d(Oi, Oj’)}

En nuestro caso, todos los objetos de P y Q tienen asociado un conjunto de atributos espaciales AP y AQ tal que los objetos espaciales O.AP y O.AQ pertenecen a E(k), y d es la distancia Euclídea.

Es decir, la Consulta del Par más Lejano (CPL) de dos conjuntos de objetos espaciales P y Q nos devuelve un par que tiene la distancia Euclídea más grande entre todos los posibles pares de objetos espaciales que pueden formarse escogiendo un objeto de P y otro objeto de Q.

Definición. Consulta de los K Pares más Lejanos. K-CPL. Dados dos conjuntos no vacíos P y Q (P ≠ ∅ y Q ≠ ∅), la consulta de los K pares más lejanos se define como un conjunto conteniendo subconjuntos de P×Q, cada uno de ellos con K (1≤K≤|P|·|Q|) pares de objetos distintos y ordenados en ranking según su distancia. Es decir, como el siguiente conjunto:

K-CPL(P, Q, K) = {{(O1, O1’), (O2, O2’), ..., (OK, OK’)} ⊆ P×Q; (Oi, Oi’) ≠ (Oj, Oj’) ∀i≠j:

∀(Oi, Oj’) ⊆ P×Q, – {(O1, O1’), (O2, O2’), ..., (OK, OK’)}, Oi ∈ P, Oj’ ∈ Q,

d(O1, O1’) ≥ d(O2, O2’) ≥ ... ≥ d(OK, OK’) ≥ d(Oi, Oj’)}

En este caso, al igual que para CPC, todos los objetos de P y Q tienen asociado un conjunto de atributos espaciales AP y AQ tal que los objetos espaciales O.AP y O.AQ pertenecen a E(k), y d es la distancia Euclídea.

Es decir, la Consulta del los K Pares más 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 según su distancia Euclídea, y que tienen las K distancias más 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 más lejano, debemos tener en cuenta las siguientes consideraciones:


161

1. parMasLejano.distancia = 0.

2. Para nodos internos:

2.1. No debemos utilizar el mínimo de MinMaxDist como cota superior de poda.

2.2. Debemos utilizar MaxMaxDist como métrica de distancia para la poda y no MinMinDist, dando lugar a una lista que denominamos LISTAMAXMAXDIST.

2.3. Ordenar la nueva lista LISTAMAXMAXDIST de mayor a menor valor de distancia MaxMaxDist.

2.4. Llamar recursivamente a la función si LISTAMAXMAXDIST.MaxMaxDist[t] ≥ parMasLejano.distancia.

3. Para nodos hoja:

3.1. Si MinMinDist(pi.MBR, qj.MBR) ≥ parMasLejano.distancia, entonces se selecciona el par (pi, qj) como el más lejano encontrado hasta el momento.

Si deseamos diseñar el algoritmo KCPL_Recursivo_MAXMAXDIST_Ordenado para obtener los K vecinos más lejanos, debemos tener en cuenta las siguientes consideraciones:

1. El montículo mínimo adicional que utilizamos para almacenar los K pares más lejanos (KMasLejanos) debe estar organizado según las distancias de pares de objetos, estando el par con menor distancia (el más cercano de los K más lejanos) en la raíz del montículo. Inicialmente, todos los elementos del montículo deben estar inicializados a 0.


2.1. Debemos utilizar MaxMaxDist como métrica 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 función si LISTAMAXMAXDIST.MaxMaxDist[t] ≥ KMasLejanos.obtenerMinimo().distancia.

3. Para nodos hoja:

3.1. Si MinMinDist(pi.MBR, qj.MBR) ≥ KMasLejanos.obtenerMinimo().distancia, entonces se selecciona el par (pi, qj) para incluirlo en el montículo mínimo adicional KMasLejanos.

Si deseamos establecer el algoritmo iterativo CPL_Monticulo_MAXMAXDIST para obtener el par más lejano, debemos tener en cuenta las siguientes consideraciones:

1. parMasLejano.distancia = 0.

Capítulo 5

162

2. El montículo principal de pares de MBRs que se utiliza para evitar la recursividad debe estar organizado según máximas distancias (clave = MaxMaxDist), estando el mayor de todos ellos en la raíz del montículo (montículo máximo).

3. Procesar los elementos del montículo principal mientras Elem.MaxMaxDist ≥ parMasLejano.distancia.


4.1. No debemos utilizar el mínimo de MinMaxDist como cota superior de poda.

4.2. Debemos utilizar MaxMaxDist como métrica de distancia para la poda y no MinMinDist.

4.3. Insertar en el montículo principal pares de MBRs si MaxMaxDist(pi.MBR, qj.MBR) ≥ parMasLejano.distancia.

5. Para nodos hoja:

5.1. Si MinMinDist(pi.MBR, qj.MBR) ≥ parMasLejano.distancia, entonces se selecciona el par (pi, qj) como el más lejano encontrado hasta el momento.

Si deseamos diseñar el algoritmo iterativo KCPL_Monticulo_MAXMAXDIST para obtener los K pares más lejanos, debemos tener en cuenta las siguientes consideraciones:

1. El montículo mínimo adicional que utilizamos para almacenar los K pares más lejanos (KMasLejanos) debe estar organizado según las distancias de pares de objetos, estando el par con menor distancia (el más cercano de los K más lejanos) en la raíz del montículo. Inicialmente, todos los elementos del montículo deben estar inicializados a 0.

2. El montículo principal de pares de MBRs que se utiliza para evitar la recursividad debe estar organizado según máximas distancias (clave = MaxMaxDist), estando el mayor de todos ellos en la raíz del montículo (montículo máximo).

3. Procesar los elementos del montículo máximo principal mientras Elem.MaxMaxDist ≥ KMasLejanos.obtenerMinimo().distancia.


4.1. Debemos utilizar MaxMaxDist como métrica de distancia para la poda y no MinMinDist.

4.2. Insertar en el montículo principal pares de MBRs si MaxMaxDist(pi.MBR, qj.MBR) ≥ KMasLejanos.obtenerMinimo().distancia.

5. Para nodos hoja:


163

5.1. Si MinMinDist(pi.MBR, qj.MBR) ≥ KMasLejanos.obtenerMinimo().distancia, entonces se selecciona el par (pi, qj) para incluirlo en el montículo mínimo adicional KMasLejanos.

Para resolver esta consulta, extendiendo el algoritmo basado en un recorrido en anchura combinado con una selección de primero el mejor, debemos realizar las mismas consideraciones que para CPL_Monticulo_MAXMAXDIST y KCPL_Monticulo_MAXMAXDIST, teniendo en cuenta que el montículo máximo principal hay que dividirlo según el número 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 condición de que para procesar el montículo del nivel siguiente, el montículo del nivel actual debe estar completamente vacío.

5.7 Auto-consulta de los pares más cercanos (Auto-CPC)

Esta operación (Auto-CPC y Auto-K-CPC) es un caso especial de la consulta del par más cercano (CPC) y de los K pares más 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, RP ≡ RQ) para determinar cuáles son los objetos más cercanos entre sí. El esquema básico para esta consulta en función de las estructuras de datos que intervienen en ella se muestra en la Figura 5.7.

RP

Auto-K-CPC


distanciaPodaKCPC

RP

ParMasCercano.distancia

RP RP

Auto-CPC

Figura 5.7 Estructuras de datos para el procesamiento de Auto-CPC y Auto-K-CPC.

Para dar solución a esta operación, los algoritmos presentados anteriormente pueden modificarse de forma sencilla a nivel de nodos hoja (nP y nQ), verificando simultáneamente las siguientes restricciones sobre los pares de objetos candidatos al resultado final (pi, qj):

1. El par (pi, qj) puede incluirse en el resultado final si y sólo si pi ≠ qj.

Capítulo 5

164

2. El par (pi, qj) puede incluirse en el resultado final si y sólo si (qj, pi) no está ya incluido (par simétrico).

El esqueleto de la implementación para resolver la operación Auto-CPC, adaptando los algoritmos de la consulta del par más 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(pi.MBR, qj.MBR); 14 if (autoCPC) then 15 if dist ≤ parMasCercano.distancia then 16 if (pi ≠ qj) then 17 if (parMasCercano.parObjetos ≠ (qj, pi)) then 18 parMasCercano.distancia = dist; 19 parMasCercano.parObjetos = (pi, qj); 20 endif 21 endif 22 endif 23 else 24 if dist ≤ parMasCercano.distancia then 25 parMasCercano.distancia = dist; 26 parMasCercano.parObjetos = (pi, qj); 27 endif 28 endif 29 enddo 30 enddo 31 endif 32 endif

Para resolver la operación Auto-K-CPC, tanto para las versiones recursivas como para las iterativas, necesitamos una tabla hash adicional (Auto_Tabla_Hash) vinculada al montículo máximo 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 condición y detectar si el simétrico de un par (qj, pi) está ya almacenado en el montículo KMasCercanos, cuando estamos procesando el par (pi, qj), evitando almacenar información duplicada.

El esquema en el que hay vinculada una tabla hash (Auto_Tabla_Hash) al montículo donde se almacenan los K pares más 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


165

a la de Tabla_Hash utilizada en los algoritmos iterativos para obtener los K pares más cercanos haciendo uso de la regla de poda basada en la métrica MaxMaxDist.

KMasCercanos ···

0

Auto_Tabla_Hash

1

2

N – 1

Figura 5.8 Tabla hash organizada por listas enlazadas vinculada a un montículo mínimo de

pares de puntos (KMasCercanos), utilizando como clave de ordenación la distancia Euclídea entre ellos.

El esqueleto de la implementación de esta operación (Auto-K-CPC) adaptando los algoritmos recursivos de la consulta de los K pares más cercanos es el que se muestra a continuación:

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(pi.MBR, qj.MBR); 14 if (autoCPC) then 15 if KMasCercanos.estaLleno() then 16 if dist ≤ distanciaPodaKCPC then 17 if (pi ≠ qj) then 18 if (not(KMasCercanos.parEnMonticulo(q j, pi))) then 19 KMasCercanos.eliminarMaximo(); 20 KMasCercanos.insertarElemento(dist, p i, qj); 21 if KMasCercanos.obtenerMaximo().distancia < distanciaPodaKCPC then 22 distanciaPodaKCPC = KMasCercanos.obtenerMaximo().distancia; 23 endif 24 endif 25 else 26 KMasCercanos.insertarElemento(dist, p i, qj);

Capítulo 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, qj); 35 if KMasCercanos.obtenerMaximo().distancia < distanciaPodaKCPC then 36 distanciaPodaKCPC = KMasCercanos.obtenerMaximo().distancia; 37 endif 38 endif 39 else 40 KMasCercanos.insertarElemento(dist, p i, qj); 41 endif 42 endif 43 enddo 44 enddo 45 endif 46 endif

Evidentemente, todas las operaciones sobre el montículo máximo (KMasCercanos) que realicen alguna modificación del mismo, deben también verse reflejadas en la tabla hash (Auto_Tabla_Hash) que tiene asociada.

También debemos destacar que la extensión a los algoritmos iterativos es inmediata, bien sea utilizando una estrategia de búsqueda de primero el mejor basada en un montículo mínimo global o siguiendo un recorrido en anchura combinado con una función de selección de primero el mejor sobre cada uno de los montículos que forman la lista de montículos mínimos por niveles.

5.8 Semi-consulta de los pares más cercanos (Semi-CPC)

Como hemos comentado anteriormente, en [HjS98] se presenta la operación 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 más próximo en Q. Es decir, esta operación es un subconjunto del Join Basado en Distancias donde un par de objetos (pi, qj), pi ∈ P aparece una sola vez en el resultado final y está ligado con el objeto más cercano qj ∈ Q. Por tanto, el método para realizar esta operación es seguir la pista de un conjunto de pares de objetos (vectorParesObjetos) con la primera componente fija pi ∈ P ((pi, *)), cuyo par (pi, qj) es el más cercano a cualquier objeto qj ∈ Q en un momento determinado de la ejecución del algoritmo. Evidentemente, la cardinalidad del conjunto resultado para esta operación será |P|. El esquema básico de las estructuras de datos asociadas a esta operación se muestra en la Figura 5.9.


167


Semi-CPC

vectorParesObjetos (global)

(p0.OBJ, qj.OBJ) ... ... (p1.OBJ, q j.OBJ) (pi.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 ocurría con la consulta del par más cercano, la aproximación más intuitiva que se nos plantea consiste en que para cada objeto en P, se ejecuta una consulta del vecino más próximo en Q, ordenándose de menor a mayor el array resultante de pares de objetos según 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 operación, 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. Después de una extensa comparación de resultados, llegaron a la conclusión 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 RP cargados en memoria durante la ejecución del algoritmo. Para resolver este mismo problema vamos a adaptar nuestros algoritmos a las dos últimas políticas, 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 RP junto con el elemento de RQ con mínima distancia entre ellos. El esquema de esta variante es el que se muestra en la Figura 5.9, siendo pi.obj los elementos almacenados en las hojas del R*-tree RP.

• GlobalTodos. Esta variante está fundamentada en la idea de que para cada MBR de los nodos internos de RP (pi.MBR), se puede tener almacenada la distancia MinMaxDist(pi.MBR, qj.MBR) más pequeña 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 RP y tener en cada una la mínima MinMaxDist de ese MBR de RP con cualquier otro MBR de RQ encontrado hasta el momento. Al considerar un par de MBRs (pi.MBR, qj.MBR) para ser procesado, debemos estar seguros de que MinMaxDist(pi.MBR, qj.MBR) es menor o igual que la menor de las distancias MinMaxDist para pi.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 RP está

Capítulo 5

168

almacenado completamente en memoria: los objetos de las hojas de RP en vectorParesObjetos y los MBRs de RP en vectorParesMBRs, además de una tabla hash (según pi.OBJ y pi.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.


Semi-CPC

vectorParesMBRs

(global)

(global)

vectorParesObjetos

(p0.OBJ, q j.OBJ) ... ... (p1.OBJ, q j.OBJ) (pi.OBJ, qj.OBJ) (p|P|.OBJ, q j.OBJ)

(p0.MBR, qj.MBR) ... ... (p1.MBR, q j.MBR) (pi.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 = número de MBRs en el R*-tree RP.

El algoritmo general para adaptar la versión recursiva de K-CPC y resolver la operación de Semi-CPC utilizando la variante GlobalTodos sobre dos R*-trees con la misma altura es el que se muestra a continuación:

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(pi.MBR, qj.MBR) ≤ vectorParesMBR(p i.MBR).MinMaxDist then 06 nP’ = LeerNodo(pi.direccion); 07 nQ’ = LeerNodo(qi.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(pi.MBR, qj.MBR); 16 if dist ≤ vectorParesObjetos(p i).distancia then 17 vectorParesObjetos(p i).distancia = dist; 18 vectorParesObjetos(p i).parObjetos = (pi, qj);


169

19 endif 20 enddo 21 enddo 22 endif

donde la función 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(pi.MBR, qj.MBR) < LISTAMnMxDIST[i].MinMaxDist then 05 LISTAMnMxDIST[i].MinMaxDist = MinMaxDist(pi.MBR, qj.MBR); 06 LISTAMnMxDIST[i].MBR_P = pi.MBR; 07 LISTAMnMxDIST[i].MBR_Q = qj.MBR; 08 endif 09 enddo 10 enddo 11 for every entrada ei 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 ocurría con las otras extensiones, podemos adaptar fácilmente estas modificaciones a los algoritmos iterativos, bien sea utilizando una estrategia de búsqueda de primero el mejor basada en un montículo mínimo global o siguiendo un recorrido en anchura combinado con una función de selección de primero el mejor sobre cada uno de los montículos que forman la lista de montículos mínimos por niveles.

Siguiendo las directrices indicadas al comienzo de este capítulo, se puede adaptar este algoritmo (Semi_Recursivo_CPC_GlobalTodos) para realizar el tratamiento sobre R*-trees con diferentes alturas siguiendo cualquiera de las dos técnicas estudiadas fijar la raíz o fijar las hojas.

5.9 Conclusiones

En este capítulo se han descrito las extensiones más representativas de los algoritmos branch-and-bound presentados anteriormente que encuentran el par más cercano de dos conjuntos de objetos indexados en sendos R*-trees, con el objetivo de mostrar la gran operatividad de los mismos. Además, junto con las descripciones de dichas extensiones se han propuesto algoritmos, estructuras de datos adicionales y detalles de implementación que nos permitirán llevarlas a cabo.

Son muchas las extensiones a la consulta del par más cercano que se podían haber planteado, pero hemos querido destacar las más representativas:

Capítulo 5

170

1. Tratamiento sobre R*-trees con diferentes alturas, proponiendo las alternativas de fijar la raíz y fijar las hojas sobre el recorrido simultáneo de ambos árboles.

2. Extensión de la consulta donde los objetos indexados no están 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 estaría guardada la representación exacta de los mismos.

3. Generalización de la consulta del par más cercano para obtener los K pares más cercanos desde un punto de vista algorítmico. Para este caso proponemos nuevas heurísticas de poda y las estructuras de datos necesarias para poder extender los algoritmos branch-and-bound diseñados en el capítulo anterior.

4. Obtener todos los pares o solamente los K más cercanos dentro de un rango de distancia determinado dado a priori es una extensión interesante y de gran utilidad, ya que combina nuestra consulta en cuestión con la delimitación del resultado dentro de un rango en el dominio solución (consulta en rango).

5. La consulta del par más lejano y de los K pares más lejanos es otro caso de estudio a considerar. Los algoritmos branch-and-bound que dan respuesta a esta consulta están basados en la métrica MaxMaxDist y utiliza heurísticas de poda similares a las de los pares más cercanos.

6. La Auto-consulta de los pares más cercanos consiste en combinar un conjunto de objetos de entrada indexado en su correspondiente R*-tree consigo mismo para determinar cuáles son los objetos más cercanos entre sí. Como tal extensión, tiene como base los algoritmos branch-and-bound previamente estudiados, además 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 más cercanos, encuentra, para cada objeto indexado en un R*-tree, el objeto más cercano indexado en el otro árbol. Los algoritmos branch-and-bound que la llevan a cabo son similares a los diseñados en el capítulo anterior salvo que hay que mantener información adicional del primer R*-tree para que la poda sea más efectiva durante el recorrido sincronizado de ambos árboles. Para esta extensión proponemos dos alternativas denominadas GlobalObjetos y GlobalTodos.

La evaluación de las extensiones previamente planteadas requiere también un importante trabajo de análisis e implementación de las mismas, dentro de un marco experimental, para establecer su correcto funcionamiento. Toda esta labor de análisis abarca desde la definición de baterías de pruebas hasta el posterior tratamiento de resultados, tareas que se llevarán a cabo en el siguiente capítulo.

171

Capítulo 6

RESULTADOS EXPERIMENTALES Y APLICACIÓN

6.1 Introducción

Un Sistema de Bases de Datos Espacial (SBDE) almacena datos de naturaleza espacial (por ejemplo puntos, líneas, regiones, volúmenes, superficies, figuras geométricas, etc.) procedentes de fenómenos que se producen tanto sobre la superficie de la Tierra como en su interior [LaT96]. Como hemos comentado en el capítulo 3, los SGBDEs deben soportar tipos de datos espaciales en su implementación, y suministrar métodos de indexación espacial y algoritmos eficientes para el procesamiento de consultas [Güt94]. 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 más próximo, consultas sobre un rango determinado, comprobar si un determinado objeto se encuentra dentro de un rango establecido, realizar operaciones sobre mapas (unión, diferencia, intersección de mapas), etc. Además, el R-tree ha sido adoptado como método 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 más próximo, búsquedas por similitud, procesamiento de joins espaciales, etc. Sin embargo, el procesamiento eficiente de otras muchas consultas importantes no ha atraído a muchos investigadores hasta el momento. Un claro ejemplo es el caso de la consulta de los pares más cercanos sobre conjuntos de datos espaciales, de gran utilidad en SBDEs, como hemos podido comprobar en el capítulo 3 de esta tesis.

En el presente capítulo vamos a realizar un extenso análisis experimental con datos espaciales (puntos 2-dimensionales) sobre los algoritmos presentados en capítulos anteriores

Capítulo 6

172

para la consulta del par más 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, considerándose los siguientes parámetros a evaluar: número de accesos a disco, tiempo de respuesta, máximo tamaño del montículo y el número de inserciones en él para los algoritmos iterativos. A continuación, se evalúan las dos técnicas propuestas para el tratamiento de R*-trees con diferentes alturas. Después, 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 parámetro 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 páginas junto con una política de reemplazo LRU (Least Recently Used) para la consulta en cuestión, 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. También se estudian, desde el punto de vista experimental, dos de las extensiones más interesantes de la consulta de los pares más cercanos, como son las que denominamos Auto-CPC y Semi-CPC. Por último, se presentan las conclusiones de este capítulo relacionado con la experimentación de nuestros algoritmos sobre datos (puntos) de naturaleza espacial.

6.2 Resultados experimentales para CPC y K-CPC

En esta sección mostramos un amplio estudio experimental tratando de medir y evaluar la eficiencia de los algoritmos branch-and-bound recursivos e iterativos descritos en capítulos anteriores para obtener el par más cercano (CPC) y su extensión para calcular los K pares más 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. Número de accesos a disco. Este parámetro nos indica el número 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 número de operaciones de inserción y borrado de pares en las estructuras de datos adicionales para realizar la consulta. Otro parámetro que afecta a esta métrica sería el número de cálculos de distancias entre pares de objetos o MBRs que requiere la consulta.

Resultados experimentales y aplicación

173

3. Utilización de recursos adicionales como, por ejemplo, áreas de memoria principal para almacenar montículos. Debido a que las operaciones de inserción y eliminación de pares de un montículo están relacionadas con el número de objetos que actualmente se encuentran almacenados en él, también se ha tenido en cuenta el número de inserciones de pares en dicha estructura de datos.

Los objetivos de esta fase experimental son principalmente:

1. Optimizar el número de accesos a disco (fundamentalmente mediante la utilización de -buffers).

2. Reducir el tiempo global de respuesta requerido por este tipo de consulta.

3. Minimizar los recursos necesarios para realizar la consulta (tamaño máximo del montículo principal para los algoritmos iterativos).

6.2.2 Definición de los experimentos

Hemos escogido al R*-tree [BKS+90] como método de acceso espacial para los experimentos en lugar del R-tree original [Gut84], ya que el primero utiliza unas técnicas más sofisticadas para la inserción de objetos y división de nodos, tratando de reducir al máximo 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 número de caminos que hay que recorrer para encontrar un objeto determinado), generando una estructura más 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 extensión 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 extensión para dimensiones mayores es sencilla para esta estructura de índice arbórea (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 (núcleos de población de California) [SFG+93], conjuntos de puntos reales movidos aleatoriamente de posición (Figura 6.1), y conjuntos de puntos artificiales generados aleatoriamente y siguiendo una distribución uniforme.

Capítulo 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 parámetro optimizador). El tamaño de la página (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*M, según se indica en [BKS+90] como valor óptimo), utilizando precisión double para cada una de las coordenadas de los MBRs en los nodos de los R*-trees.

El objetivo principal que perseguimos con la realización 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 parámetros en la definición 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 distribución uniforme con diferentes cardinalidades (10000, 30000, 60000 y 120000).

3. Tratamiento de pares cuyo valor para MinMinDist puede ser el mismo. Las técnicas para el tratamiento de empates se pueden aplicar tanto a los algoritmos recursivos (que establecen una ordenación local según MinMinDist de pares de MBRs procedentes de la combinación de dos nodos internos) como a los iterativos (ordenación global sobre el montículo mínimo principal de pares de MBRs).

4. Máximo número de pares de MBRs almacenados en el montículo mínimo principal utilizado para los algoritmos iterativos. Éste es un parámetro importante, porque operaciones de inserción (O(log N)) y borrado del mínimo (O(log N)) sobre él, dependen del número de elementos almacenados en el montículo.


175

Para este primer estudio hemos considerado fijar una serie de parámetros (que posteriormente se analizarán con mayor detalle):

1. Para R*-trees con diferentes alturas, utilizamos la técnica 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 definición de estos experimentos en base a los anteriores parámetros nos permite evaluar y comparar en términos de eficiencia (minimizar el número de operaciones de E/S, el tiempo de respuesta y los recursos adicionales requeridos) nuestros algoritmos branch-and-bound que obtienen el par más cercano y sus extensiones más representativas.

También 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 búsqueda en profundidad (RECU), (2) iterativo utilizando un montículo mínimo global con una estrategia de búsqueda basada en una función de selección de primero el mejor (HEAP) y (3) iterativo basado en un recorrido en anchura utilizando una lista de montículos mínimos siguiendo en cada uno de ellos una estrategia de búsqueda con una función de selección de primero el mejor (BFT). Además, para las diferentes alternativas que se pueden aplicar a los anteriores algoritmos tenemos las siguientes abreviaciones: (1) no tener en cuenta ningún criterio de poda (BRU), (2) considerar MinMinDist como métrica 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 combinación de dos nodos internos (STD si se utiliza una lista local y, STM si se utiliza un montículo mínimo local), y (5) si utilizamos la técnica de Barrido del Plano (PS).

6.2.3 Presentación y análisis de los resultados

Evaluación del número de accesos a disco

La Tabla 6.1 muestra los resultados (número 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 más cercano, supone un ahorro de casi 900 veces el número de accesos a disco. El algoritmo que aplica un recorrido en profundidad en un R*-tree combinado con una consulta del vecino más próximo (R+CVP) tampoco supone ninguna mejora sobre los algoritmos branch-and-bound (casi 10 veces más de accesos a disco).

Capítulo 6

176

2. Las variantes de los algoritmos iterativos (HEAP y BFT) no se ven afectadas, obteniendo en todas el mismo número 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 gestión de un montículo (global o por niveles) de pares de MBRs organizado según 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 función de selección de primero el mejor sobre un montículo mínimo de pares de MBRs gestionado a nivel global, minimizando el número de pares de MBRs a considerar durante la ejecución del algoritmo. BFT, proporciona los peores resultados, ya que sigue una estrategia de búsqueda en anchura (aunque para cada nivel los pares de MBRs se organicen en un montículo mínimo), debiéndose 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 razón 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 más 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 según un algoritmo iterativo (HEAP utiliza un montículo mínimo global, mientras que BFT emplea una lista de montículos mínimos 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 sólo aparece una mejora de 22 accesos a disco, lo que supone un ahorro del 0.05%. De lo que deducimos, que aplicar esta métrica no afecta mucho en la reducción del número de accesos a disco, fenómeno que se aprecia claramente cuando aplicamos MinMinDist (métrica 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 Número 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:


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 número 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 montículo principal de forma global, minimizando el número de pares de MBRs a considerar y consiguiendo los mejores candidatos según MinMinDist más rápidamente, 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 Número de accesos a disco para K-CPC.

30000

38000

46000

54000

62000

70000

1 10 100 1000 10000 100000

Número de Pares

Acc

esos

a D

isco

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 también que el algoritmo recursivo que no utiliza ningún 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 más próximos en el segundo, y seleccionando los K pares con menor distancia

Capítulo 6

178

entre ellos, obtenemos los siguientes resultados para el número de accesos a disco según el valor de K: (<1, 360519>, <10, 545046>, <100, 1580073>, <1000, 8652381>, <10000, 59885634>, <100000, 272411237>). Debido a su elevado número 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 número 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 próxima 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

Número de Pares

Cos

te R

elat

ivo

RECU_STD HEAP_SIM BFT_SIM

Figura 6.3 Coste relativo de RECU_STD, HEAP_SIM y BFT_SIM respecto a RECU_EXH.

También se ha estudiado el efecto de aplicar MaxMaxDist para K-CPC (para BFT siempre se utiliza), observándose que para el número de accesos a disco no tiene ninguna trascendencia en los algoritmos iterativos, aunque sí para el número de inserciones en el montículo principal y para el tamaño máximo en número 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 número 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. Además, 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 número de accesos a disco, produciéndose un ahorro del 1.25%.


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 Tamaño máximo del montículo 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 Número de inserciones en el montículo 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 métrica MaxMaxDist sobre las variantes de los algoritmos que utilizan un montículo mínimo principal para evitar la recursividad (HEAP), respecto del tamaño máximo del montículo (Tabla 6.3) y del número de inserciones (Tabla 6.4) de/en dicha estructura de datos. De forma general, podemos decir que incluir dicha métrica favorece considerablemente a estos dos parámetros (a costa de incluir un montículo adicional MMMD, cuyo tamaño máximo en pares fue en todos los casos <2, 2, 4, 22, 206, 2042, 20410> según los valores de K), proporcionando la alternativa STD los mejores resultados, sensiblemente superiores a SIM y STM. Según los porcentajes de las Tablas 6.3 y 6.4, cuando K ≤ 100, el incluir o no dicha métrica hace que STM sea la mejor alternativa para ambos parámetros, mientras que si K ≥ 1000, PS nos proporciona los porcentajes más altos. También debemos indicar que estos mismos parámetros aplicados sobre las variantes en el algoritmo BFT, donde el montículo principal está organizado por niveles, mostró una tendencia similar en los resultados aunque con valores más altos (sobre un 67.42% superior para el tamaño máximo del montículo y del 52.47% para el número de inserciones cuando K = 100000). Otro aspecto que se debe considerar es la relación existente entre el tamaño máximo del montículo y el número de inserciones en él cuando aplicamos MaxMaxDist. Evidentemente, conforme disminuye el tamaño máximo del montículo, el número de inserciones en él es también menor, propiedad que se verifica para todos los casos, ya que el número de nodos internos que se combinan durante la ejecución del algoritmo y que se almacenan en el montículo principal será también menor.

Capítulo 6

180

Demostración del comportamiento de MinMaxDist (CPC) y MaxMaxDist (K-CPC) respecto al número de accesos a disco

En el capítulo 3 hemos definido las distancias MinMinDist, MinMaxDist y MaxMaxDist, las cuales se utilizan en heurísticas de poda (MinMinDist) y de actualización de parMasCercano.distancia para CPC (MinMaxDist) y distanciaPodaKCPC (MaxMaxDist) sobre algoritmos branch-and-bound recursivos e iterativos. Recordemos que las dos heurísticas para CPC basadas en MinMinDist y MinMaxDist son las siguientes:

1. Si parMasCercano.distancia es la distancia Euclídea del par más cercano encontrado hasta el momento (temporal), entonces todos los pares de MBRs (RPi, RQj) tal que RPi ∈ RP y RQj ∈ RQ, con distancia MinMinDist(RPi, RQj) estrictamente mayor que parMasCercano.distancia pueden descartarse, ya que estos pares de MBRs no incluirán otro par de objetos con distancia menor que parMasCercano.distancia.

2. Si un par de MBRs (RPi, RQj) tal que RPi ∈ RP y RQj ∈ RQ tiene un valor de MinMinDist(RPi, RQj) mayor que MinMaxDist(R’Pi, R’Qj) de otro par de MBRs (R’Pi, R’Qj) tal que R’Pi ∈ RP y R’Qj ∈ RQ, entonces el par (RPi, RQj) puede descartarse, porque no puede contener al par más cercano. Además, si parMasCercano.distancia es la distancia del par más cercano encontrado hasta el momento podemos actualizarla de la siguiente forma: Si MinMaxDist(RPi, RQj) < parMasCercano.distancia, entonces parMasCercano.distancia = MinMaxDist(RPi, RQj).

Los resultados experimentales mostrados en este capítulo nos indican que el uso de las heurísticas basadas en MinMaxDist para CPC y MaxMaxDist para K-CPC no supone ahorro alguno en el número de accesos a disco. Por tanto, vamos a demostrar este comportamiento para la consulta del par más cercano utilizando el algoritmo recursivo siguiendo un esquema de recorrido en profundidad y ordenando todos los posibles pares de MBRs procedentes de nodos internos según MinMinDist (CPC_Recursivo_MINMAXDIST_MINMINDIST_Ordenado), de la misma forma que se presenta en [ChF98] para el algoritmo recursivo que encuentra el vecino más próximo propuesto en [RKV95].

La demostración del comportamiento del algoritmo se podría haber hecho de dos formas: (1) en base al funcionamiento propio del algoritmo sobre los dos R*-trees y (2) estudiando el árbol de solución generado. Hemos optado por la primera, ya que resulta más sencilla e ilustrativa de seguir. Para ello, empezaremos con una serie de lemas que muestran propiedades de las métricas aplicadas al algoritmo en cuestión, y concluiremos con el teorema que demuestra su comportamiento.

Lema 6.1. Dados dos MBRs R1 y R2 de dos R*-trees en E(k), envolviendo a los conjuntos de objetos O1 = {o1i, 1≤i≤N1} y O2 = {o2j, 1≤j≤N2}, respectivamente. Si (o11, o21) es el par más cercano, entonces

MinMinDist(R1, R2) ≤ ||(o11, o21)|| ≤ MinMaxDist(R1, R2)

Demostración:


181

Por definición MinMinDist(R1, R2) es la mínima distancia entre los dos MBRs R1 y R2. Por la propiedad de las caras de un MBR en un R*-tree y si (o11, o21) es el par de objetos más cercano de los que se pueden formar estando cubiertos por R1 y R2, entonces por el teorema 3.5, se verifica que ||(o11, o21)|| ≤ MinMaxDist(R1, R2). Por tanto, MinMinDist(R1, R2) y MinMaxDist(R1, R2) sirven de cota inferior y superior para la distancia del par más cercano, respectivamente. £

Lema 6.2. Si el par de MBRs (R1’, R2’) es un ancestro del par de MBRs (R1, R2) en dos R*-trees, entonces

MinMinDist(R1’, R2’) ≤ MinMinDist(R1, R2)

Demostración:

La demostración es consecuencia inmediata de la definición de MinMinDist(R1, R2) y de la propiedad de las caras de un MBR en un R*-tree. £

Lema 6.3. Si hay dos pares de MBRs (R1, R2) y (R1’, R2’) verificando la condición MinMinDist(R1, R2) ≤ MinMinDist(R1’, R2’), entonces MinMaxDist(R1’, R2’) nunca será estrictamente menor que MinMinDist(R1, R2).

Demostración:

Por el Lema 6.1, MinMinDist(R1’, R2’) ≤ MinMaxDist(R1’, R2’). Suponiendo que se verifica la precondición MinMinDist(R1, R2) ≤ MinMinDist(R1’, R2’), tenemos que MinMinDist(R1, R2) ≤ MinMinDist(R1’, R2’) ≤ MinMaxDist(R1’, R2’), entonces MinMaxDist(R1’, R2’) nunca será estrictamente menor que MinMinDist(R1, R2). £

Lema 6.4. Dado el algoritmo branch-and-bound CPC_Recursivo_MINMAXDIST_MINMINDIST_Ordenado, si un par de MBRs (R1’, R2’) está antes que el par (R1, R2) dentro de la misma lista de pares de MBRs ordenados según MinMinDist que combina dos nodos internos de dos R*-trees a nivel local y MinMaxDist(R1’, R2’) < MinMinDist(R1, R2), entonces la distancia del par más cercano temporal encontrado hasta el momento, parMasCercano.distancia, es menor o igual que MinMaxDist(R1’, R2’) (parMasCercano.distancia ≤ MinMaxDist(R1’, R2’)) justo antes de que el par de MBRs (R1, R2) se procese o se pode.

Demostración:

Sea S el conjunto de pares de MBRs que están inmediatamente después del par (R1’, R2’) y justo antes de (R1, R2) en la misma lista que combina todos los pares de MBRs ordenados según MinMinDist procedentes de dos nodos internos. Sea (o11, o21) el par de objetos más cercano encontrado justo antes de procesar (R1, R2). Recordemos que el par (R1, R2) 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 (o11, o21) se encuentra cubierto por S. En este caso, (o11, o21) ha sido considerado como par candidato temporal (parMasCercano.distancia ≤ ||(o11, o21)||) a ser el

Capítulo 6

182

más cercano antes de procesar o podar (R1, R2) debido a que el algoritmo sigue un recorrido en profundidad, entonces sabemos que su distancia es menor o igual que MinMaxDist(R1’, R2’), es decir, ||(o11, o21)|| ≤ MinMaxDist(R1’, R2’). Por tanto, parMasCercano.distancia ≤ MinMaxDist(R1’, R2’).

Caso 2. El par de objetos (o11, o21) no se encuentra cubierto por S (se encuentra cubierto por (R1’, R2’) aunque no ha sido podado por él). Por el Lema 6.1 y la precondición de este lema, se verifica que ||(o11, o21)|| ≤ MinMaxDist(R1’, R2’) < MinMinDist(R1, R2). Además, por el Lema 6.2, tenemos que todos los pares de MBRs ancestros de (o11, o21) tienen un valor de MinMinDist menor o igual que MinMinDist(R1, R2). Como (o11, o21) no se encuentra cubierto por S, entonces un par de MBRs ancestro de (R1’, R2’), sea éste (R1’’, R2’’), debe haber sido descartado por la heurística 2 (actualizar parMasCercano.distancia utilizando MinMaxDist). Es decir, el par de MBRs (R1’’, R2’’) se descarta porque MinMinDist(R1’’, R2’’) > parMasCercano.distancia. Por tanto, parMasCercano.distancia < MinMinDist(R1’’, R2’’) ≤ MinMaxDist(R1’, R2’), entonces parMasCercano.distancia ≤ MinMaxDist(R1’, R2’). £

Lema 6.5. Dado el algoritmo branch-and-bound CPC_Recursivo_MINMAXDIST_MINMINDIST_Ordenado, si un par de MBRs se poda por la heurística 1 (MinMinDist) utilizando previamente la heurística 2 (MinMaxDist), entonces este par también se podará por la heurística 1 (MinMinDist) sin utilizar la heurística 2 (MinMaxDist), una vez que parMasCercano.distancia ha sido actualizado a nivel de hojas.

Demostración:

En este lema lo que pretendemos demostrar es lo siguiente:

poda con heurística 1 utilizando la heurística 2 ⇒ poda con heurística 1 sin utilizar la heurística 2

La heurística 2 dice que, si MinMinDist(R1, R2) > MinMaxDist(R1’, R2’), entonces el par de MBRs (R1, R2) se descartará. Sin perder generalidad, supongamos que tenemos dos pares de MBRs cualquiera (R1, R2) y (R1’, R2’) en la misma lista que combina todos los pares de MBRs ordenados según MinMinDist procedentes de dos nodos internos tal que, (R1, R2) se descarta debido a (R1’, R2’) por la heurística 2, por tanto MinMaxDist(R1’, R2’) < MinMinDist(R1, R2). Para demostrar la consecuencia de nuestra implicación debemos considerar dos casos.

Caso 1. MinMinDist(R1, R2) ≤ MinMinDist(R1’, R2’), estando el par (R1, R2) antes que (R1’, R2’) en la lista local de pares de MBRs. Según el Lema 6.1, para (R1, R2) y (R1’, R2’) tenemos las dos siguientes inecuaciones: MinMinDist(R1, R2) ≤ MinMaxDist(R1, R2) y MinMinDist(R1’, R2’) ≤ MinMaxDist(R1’, R2’).

Por el Lema 6.3, sabemos que si dos pares de MBRs (R1, R2) y (R1’, R2’) verificando la condición MinMinDist(R1, R2) ≤ MinMinDist(R1’, R2’), entonces MinMaxDist(R1’, R2’) nunca será estrictamente menor que MinMinDist(R1, R2). Por tanto, es imposible que MinMaxDist(R1’, R2’) < MinMinDist(R1, R2), y con ello es imposible que el par de MBRs (R1, R2) sea podado por la heurística 2, podándose sólo con la heurística 1.


183

Caso 2. MinMinDist(R1, R2) > MinMinDist(R1’, R2’), estando el par (R1’, R2’) antes que (R1, R2) en la lista de combinación de pares de MBRs (no podría estar (R1, R2) antes que (R1’, R2’) puesto que la lista se ordena crecientemente en base a MinMinDist).

Sea parMasCercano.distancia la distancia del par más cercano temporal encontrado justo antes de que el par (R1, R2) sea podado o procesado. Por el Lema 6.4, parMasCercano.distancia ≤ MinMaxDist(R1’, R2’) y como MinMaxDist(R1’, R2’) < MinMinDist(R1, R2) se satisface como precondición (heurística 2), obtenemos que parMasCercano.distancia < MinMinDist(R1, R2), que es la condición de la heurística 1, y por tanto, el MBR (R1, R2) será descartado sólo por dicha heurística. £

De este lema podemos concluir que todos los pares que se podan por la heurística 1 utilizando la heurística 2, son los mismos que se podan por la heurística 1 sin utilizar la heurística 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 heurística 1 (MinMinDist) sin utilizar previamente la heurística 2 (MinMaxDist), entonces este par también se podará por la heurística 1 (MinMinDist) utilizando la heurística 2 (MinMaxDist), una vez que parMasCercano.distancia ha sido actualizado a nivel de hojas.

Demostración:

En este lema lo que pretendemos demostrar es lo siguiente:

poda con heurística 1 sin utilizar la heurística 2 ⇒ poda con heurística 1 utilizando la heurística 2

Supongamos que durante la ejecución del algoritmo hay un par de MBR (R1, R2) que verifica que MinMinDist(R1, R2) > parMasCercano.distancia, entonces el par (R1, R2) será descartado por la heurística 1. Debemos destacar también que parMasCercano.distancia puede actualizarse con la distancia de un par de objetos (o11, o21) (||(o11, o21)|| ≤ parMasCercano.distancia) o con el valor de MinMaxDist de un par de MBRs (R1’, R2’) que se encuentra en la misma lista de pares de MBRs ordenados según MinMaxDist procedente de la combinación de dos nodos internos de dos R*-trees. Si sólo utilizamos la heurística 1 sin utilizar la heurística 2, debemos considerar dos casos para demostrar la consecuencia de nuestra implicación.

Caso 1. La poda de un par de MBRs (R1’, R2’) puede deberse a que se haya podado un par de MBRs ancestro. Puesto que si (R1’, R2’) no está en las raíces respectivas de los dos R*-trees, entonces debe haber un par ancestro a (R1’, R2’) que se procese antes que éste, sea este par de MBRs ancestro (R1’’, R2’’). Por el Lema 6.2, el par de MBRs ancestro (R1’’, R2’’) tiene que tener un valor de MinMinDist menor que ||(o11, o21)|| (MinMinDist(R1’’, R2’’) < ||(o11, o21)||), y esto también se verifica para todos los pares de MBRs ancestros entre (R1’, R2’) y (R1’’, R2’’). Si (R1’, R2’) se poda, entonces dicha poda se debe a la heurística 1 aplicada a algunos de sus ancestros, de la misma forma que se puede llevar a cabo utilizando la heurística 2 (MinMinDist(R1’, R2’) > MinMaxDist(R1, R2) entonces el par (R1’, R2’) será descartado).

Capítulo 6

184

Caso 2. La poda de un par de MBRs (R1’, R2’) puede deberse también a que parMasCercano.distancia sea actualizada con la distancia de un par de objetos (o11, o21) que ha sido considerado como candidato temporal a ser el más cercano. Sea parMasCercano.distancia la distancia del par de objetos más cercano antes de podar el par de MBRs (R1’, R2’). Puesto que, para actualizar parMasCercano.distancia se debe haber verificado que parMasCercano.distancia ≤ ||(o11, o21)||, y además se cumple que MinMinDist(R1’, R2’) < ||(o11, o21)|| antes de que (R1’, R2’) se pode, entonces MinMinDist(R1’, R2’) > parMasCercano.distancia y el par de MBRs (R1’, R2’) se podará por la heurística 1, de la misma forma que se puede llevar a cabo utilizando la heurística 2 (MinMinDist(R1’, R2’) > MinMaxDist(R1, R2) entonces el par (R1’, R2’) será descartado). £

De este lema podemos concluir que todos los pares que se podan por la heurística 1 sin utilizar la heurística 2, son los mismos que se podan por la heurística 1 utilizando la heurística 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 heurística 1 (MinMinDist) utilizando previamente la heurística 2 (MinMaxDist), este par se podará de igual forma sin utilizar la heurística 2 (MinMaxDist).

Demostración:

Para demostrar este teorema debemos considerar la siguiente equivalencia:

poda con heurística 1 utilizando la heurística 2 ⇔ poda con heurística 1 sin utilizar la heurística 2

1. poda con heurística 1 utilizando la heurística 2 ⇒ poda con heurística 1 sin utilizar la heurística 2. La demostración de esta implicación se obtiene de forma inmediata del Lema 6.5.

2. poda con heurística 1 sin utilizar la heurística 2 ⇒ poda con heurística 1 utilizando la heurística 2. La demostración de esta implicación se obtiene de forma inmediata del Lema 6.6. £

Como aclaración, si un acceso a un nodo en un R*-tree se corresponde con un acceso a disco, entonces utilizar la heurística de poda 1 previa utilización de la heurística 2 (una vez que parMasCercano.distancia ha sido actualizado a nivel de hojas) no supone ningún ahorro en el número de accesos a disco comparado con utilizar únicamente la heurística 1, aplicadas en un algoritmo branch-and-bound recursivo para CPC, ordenando los pares de MBRs procedentes de la combinación de dos nodos internos de dos R*-trees según su MinMinDist (CPC_Recursivo_MINMAXDIST_MINMINDIST_Ordenado).

La conclusión que podemos obtener de este teorema es que actualizar parMasCercano.distancia (una vez que éste ha sido actualizado a nivel de hojas) con la heurística 2 (basada en MinMaxDist) a nivel local no supone ningún ahorro en el número de accesos a disco, aplicada sobre un algoritmo recursivo para CPC, ordenando los pares de MBRs procedentes de la combinación de dos nodos internos de dos R*-trees según su


185

MinMinDist (CPC_Recursivo_MINMAXDIST_MINMINDIST_Ordenado). Por otro lado, no utilizar dicha heurística supone un ahorro de cálculo, pues obtener el valor de MinMaxDist entre dos MBRs tiene un coste que depende del número de dimensiones que intervienen en la operación.

La demostración para K-CPC utilizando la heurística 2 basada en MaxMaxDist(R1, R2) y aplicada a la extensión del anterior algoritmo branch-and-bound recursivo propuesta en el capítulo 5 (KCPC_Recursivo_MAXMAXDIST_MINMINDIST_Ordenado) es muy similar. Dicha heurística de poda nos dice, de forma general, que actualizar la variable distanciaPodaKCPC utilizando MaxMaxDist, la altura de los R*-trees y su mínimo valor de factor de ramificación (m1, m2), podaba subárboles de los R*-trees para K-CPC de la misma manera que la heurística de poda basada en MinMaxDist lo hace para CPC.

La demostración para el algoritmo recursivo optimizado con la técnica del barrido del plano y para el iterativo basado en una política de búsqueda de primero el mejor (minimiza el número 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 según su MinMinDist. Por ello, aplicar estas heurísticas de poda para CPC (MinMaxDist) y K-CPC (MaxMaxDist) no supone ningún ahorro en el número de accesos a disco una vez alcanzado el nivel de hojas, pero sí reduce notablemente el número de pares de MBRs insertados en el montículo principal empleado para esta versión iterativa, tal y como observamos en los resultados experimentales para este parámetro.

Por tanto, la heurística 1 es la realmente eficiente para el proceso de poda durante la ejecución de algoritmos branch-and-bound tanto recursivos como iterativos, que decía “si MinMinDist(R1, R2) > valorCotaTemporal, entonces el par de MBRs (R1, R2) 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 parámetros 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 número 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 habían sido generados aleatoriamente y siguiendo una distribución uniforme fueron similares (resultados no mostrados aquí).

Capítulo 6

186

0

15000

30000

45000

60000

75000

R/10K R/30K R/60K R/120K

Combinación de los Conjuntos de Datos

Acc

esos

a D

isco


Figura 6.4 CPC, combinando puntos reales con reales movidos aleatoriamente.

Según 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, fenómeno que si se aprecia en los algoritmos iterativos (HEAP_SIM y BFT_SIM). En ambos casos, el incremento de K se puede apreciar con más notoriedad cuando pasamos de K = 10000 a K = 100000, aunque para los algoritmos recursivos dicho incremento es menos pronunciado.

110 100

100010000

10000010K

30K

60K

120K0

14000

28000

42000

56000

70000

Acc

esos

a D

isco

Número de Pares

Conjuntos

0-14000 14000-28000 28000-42000 42000-56000 56000-70000

110 100

100010000 100000

10K

60K0

14000

28000

42000

56000

70000

Acc

esos

a D

isco

Número de Pares

Conjuntos

0-14000 14000-28000 28000-42000 42000-56000 56000-70000

RECU_EXH RECU_STD


187

1 10100 1000

10000100000

10K

30K

60K

120K0

18000

36000

54000

72000

90000

Acc

esos

a D

isco

Número de Pares

Conjuntos

0-18000 18000-36000 36000-54000 54000-72000 72000-90000

1 10100 1000

10000100000

10K

30K

60K

120K0

22000

44000

66000

88000

110000

Acc

esos

a D

isco

Número 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 Número 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

Número de Pares

Acc

esos

a D

isco


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 señalar también que combinando conjuntos de

Capítulo 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 política de tratamiento de empates (menor nivel y MBR más pequeño en caso de empate) y no considerar ninguna. Todos ellos sobre diferentes cardinalidades y naturalezas de datos, con respecto al número máximo de pares de MBRs almacenados en el montículo mínimo principal y el número de inserciones en dicha estructura de datos. En estos experimentos, se ha considerado el efecto de añadir MaxMaxDist, ya que como se ha comprobado anteriormente afecta beneficiosamente a estos dos parámetros.

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 políticas enunciadas en el capítulo 4, obteniendo las dos siguientes conclusiones:

1. Respecto al número 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 más pequeño (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 más rápidamente. Sin embargo, no considerar ningún 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 ningún momento a las dos anteriores. También 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 número de accesos a disco.

2. Los algoritmos iterativos tanto para CPC como para K-CPC no se ven afectados en cuanto al número de accesos a disco, pero sí respecto al tamaño máximo del montículo principal y al número 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 Tamaño máximo del montículo, considerando y sin considerar un tratamiento de empates.


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 Número de inserciones en el montículo 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 montículo mínimo 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 tamaño máximo del montículo principal de ganancia al aplicar el tratamiento de empates se reduce. Por otro lado, respecto al número de inserciones, al aumentar K aumenta también el porcentaje de ahorro al aplicar la mejor política 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 más cercanos en su variante SIM, respecto al tamaño máximo del montículo principal (global o por niveles) y al número de inserciones de pares de MBRs en él. En los experimentos se considera MaxMaxDist y la mejor política para el tratamiento de empates (menor nivel y MBR más pequeño en caso de empate), ya que afectan considerablemente a estos dos parámetros 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 montículo principal es muy grande (75%-99%) y en lo que respecta al número de inserciones es también 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 Tamaño máximo del montículo principal, para HEAP y BFT.

Capítulo 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 Número de inserciones en el montículo 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.

Evaluación del tiempo de respuesta

Por último, el parámetro 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 versión recursiva es la más rápida, aunque la diferencia con respecto a la versión iterativa que utiliza un montículo global (HEAP) es menor que emplear la alternativa que organiza el montículo principal por niveles junto con un recorrido en anchura (BFT). Es evidente que la gestión del montículo principal requiere su tiempo y hacerlo por niveles es más costoso.

2. Debido a que PS está pensada como variante que optimiza el tiempo de respuesta (no considera la combinación 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 cuestión, siendo del orden del 58% (2.36 segundos) más rápida que EXH en la versión recursiva y del 47% (2.2 segundos) para la iterativa. Además, utilizar la versión recursiva de PS supone una mejora del 32% con respecto a la versión iterativa utilizando un montículo global (HEAP).


191

3. Aplicar MinMaxDist (SIM) hace que el algoritmo sea más 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 más tiempo necesitan, ya que además de considerar MinMaxDist necesitan un tiempo adicional para ordenar la lista de pares (STD) o mantener un montículo mínimo 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 más elevados para este parámetro en evaluación. Esto es debido fundamentalmente a la gestión que tiene que hacer sobre el montículo principal organizado por niveles, que como hemos visto, hace que éste tenga muchos más pares almacenados en él y por tanto el número de inserciones sea también mayor que considerar un montículo mínimo 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.

Capítulo 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. Además, si no consideramos MaxMaxDist ni el tratamiento de empates (Tabla 6.11) obtenemos menor tiempo de respuesta que considerándolos (Tabla 6.12). La razón es que, teniendo en cuenta estos parámetros para reducir el tamaño del montículo y el número de inserciones en él hace que el tiempo global requerido por la consulta sea mayor. Este fenómeno 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 montículos que se van generando. También es interesante destacar que todas las versiones de HEAP, cuando K = 100000 tienen un tiempo de respuesta menor que sus homónimas 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 experimentación, destacando que cuando K ≥ 100000, HEAP_PS es la alternativa más rápida.

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.


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 más suave y no tan pronunciada. Este fenómeno es debido fundamentalmente a dos factores: el valor de K y la técnica utilizada para el recorrido de los R*-trees. Cuanto mayor es el valor de K, después de llenar el montículo máximo adicional donde se almacena en resultado (KMasCercanos), se necesitan más operaciones de actualización (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 más cercanos. Por otra parte, el algoritmo iterativo que utiliza una estrategia de búsqueda de primero el mejor basada en un montículo mínimo global, cuando alcanza el nivel de las hojas, produce los mejores pares candidatos, obteniendo muy rápidamente los K más cercanos y tendiendo que realizar menos operaciones de actualización sobre KMasCercanos. Por ello, HEAP gasta menos tiempo en la respuesta a la consulta y tiene un número de accesos a disco menor.

0

28

56

84

112

140

1 10 100 1000 10000 100000 200000 500000 1000000

Número de Pares

Tie

mpo

de

Res

pues

ta (

seg.

)

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.

También 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 número de accesos a disco se mantiene. Es decir, la mejor alternativa es HEAP, seguido de BFT y por último la versión recursiva.

Capítulo 6

194

6.2.4 Conclusiones

Las conclusiones generales que podemos extraer de esta fase experimental son las siguientes:

1. Respecto al número 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 según MinMinDist a nivel local provoca que los pares de objetos más cercanos se encuentren con mayor rapidez.

1.2. Aplicar MinMaxDist para CPC y MaxMaxDist para K-CPC no supone un ahorro sustancial en el número 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, máxime 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 número de accesos a disco.

2. Respecto al tamaño máximo y al número de inserciones del/en montículo principal para los algoritmos iterativos.

2.1. Utilizar MaxMaxDist y la mejor política de tratamiento de empates (los MBRs que forman el par tienen el mismo valor de MinMinDist) nos proporcionan una considerable reducción de ambos parámetros para K-CPC.

2.2. Ya que aplicar estas dos técnicas (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 parámetros.

2.3. Además, aplicar la heurística 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:


195

3.1. La versión recursiva es la más rápida, aunque cuando los valores de K son muy grandes (K ≥ 100000) las alternativas iterativas tienen un mejor comportamiento ante este parámetro, siendo HEAP la mejor de ellas.

3.2. La variante PS es la que menor tiempo necesita para la ejecución de las consultas, destacando que EXH tiene un comportamiento muy cercano a PS.

3.3. Aplicar la heurísticas de poda basadas en MinMaxDist (CPC) y MaxMaxDist (K-CPC), junto con el tratamiento de empates hace que los algoritmos sean más 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 parámetros en estudio, descartando a BFT para los sucesivos experimentos. Por tanto, se entiende que es mejor organizar un montículo de forma global (HEAP) que por niveles siguiendo un recorrido en anchura (BFT).

6.3 Utilización de R*-trees con diferentes alturas

Como complemento a la anterior sección 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 técnicas descritas en el capítulo 5: Fijar las Hojas y Fijar la Raíz, que denotaremos como FH y FR, respectivamente.


En primer lugar, en la Tabla 6.14 presentamos los resultados del número 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 técnica 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 rápidamente.

Capítulo 6

196

2. Aplicar la técnica de Fijar la Raíz es beneficioso para el algoritmo iterativo, ya que éste sigue un recorrido basado en una política de primero el mejor, y cuantos más MBRs combine en niveles superiores, el valor de parMasCercano.distancia se reducirá más rápidamente, haciendo que la poda sea más efectiva.

3. Cuando aplicamos la técnica de Fijar la Raíz a CPC, tanto para los algoritmos recursivos como para los iterativos, los resultados han sido muy próximos (HEAP ligeramente mejor). Por tanto, podemos observar que esta técnica reduce la potencia de los algoritmos recursivos (necesita combinar más nodos internos antes de llegar a las hojas sin reducir notablemente el valor de parMasCercano.distancia) y aumenta el rendimiento de los iterativos (combina más pares de nodos internos, actualiza más rápidamente el valor de parMasCercano.distancia y por ello la poda es más efectiva cuando se combinan más 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 Número 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 técnicas 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, después de aplicar las técnicas Fijar las Hojas (FH) y Fijar la Raíz (FR). Por el contrario, el algoritmo iterativo utilizando la técnica Fijar la Raíz obtuvo el menor número 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 montículo mínimo global siguen una política de selección de primero el mejor, y cuando empiezan a procesar las hojas encontrarán rápidamente los K óptimos puesto que extraerán del montículo los mejores pares candidatos según MinMinDist. Por otro lado, los algoritmos recursivos, cuanto mayor es el K, para llenar y actualizar KMasCercanos necesitan la realización 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 ocurría en el caso de que los R*-trees tuvieran la misma altura.

3. Aplicar Fijar la Raíz (FR) supone un ahorro en el número de accesos a disco con respecto a Fijar las Hojas (FH) para el algoritmo iterativo según el valor de K del


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 más afectados que los recursivos cuando se utiliza MaxMaxDist para actualizar distanciaPodaKCPC, puesto que la actualización a nivel global (iterativos) es más beneficiosa que la local (recursivos), y (2) fijar la raíz 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 actualización lo suficientemente efectiva sobre distanciaPodaKCPC.

4. La técnica Fijar la Raíz hace que los algoritmos iterativos tengan un número menor de accesos a disco que los recursivos para cualquier valor de K, situación opuesta a la de aplicar Fijar las Hojas. La razón fundamental de que para los algoritmos recursivos Fijar las Hojas sea siempre mejor que Fijar la Raíz es, porque según el recorrido (sincronizado en profundidad) que emplean, cuanto más tarden en llegar a las hojas, más tardía será la actualización de distanciaPodaKCPC (número de accesos a disco, tiempo de respuestas, etc.). En cambio, para los algoritmos que utilizan un montículo global con una función de selección de primero el mejor, cuantos más pares de MBRs se combinen en niveles superiores, mejores candidatos habrá en el montículo mínimo global en el momento de procesar las hojas y la actualización de distanciaPodaKCPC será mejor puesto que se hace a nivel global en función 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 Número 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

Número de Pares

Acc

esos

a D

isco

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 técnicas de Fijar las Hojas (FH) y Fijar la Raíz (FR).

Capítulo 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 técnicas Fijar las Hojas (FH) y Fijar la Raíz (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 Raíz.

Influencia de aplicar la heurística 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 Raíz sobre las variantes del algoritmo iterativo que utiliza un montículo mínimo global (HEAP) para el número de inserciones en el montículo y el tamaño máximo del mismo en número de pares de MBRs. Para CPC en las Tablas 6.16 y 6.17 se comparan los resultados sin considerar y considerando la heurística 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 sección anterior, considerar estas técnicas de optimización suponen un gran ahorro para estos dos parámetros (tamaño máximo y número de inserciones de/en montículo global).

SIN CONSIDERAR OPTIMIZACIÓN CONSIDERANDO OPTIMIZACIÓN

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 Tamaño máximo del montículo para CPC utilizando el algoritmo iterativo HEAP, considerando y sin considerar técnicas de optimización.

SIN CONSIDERAR OPTIMIZACIÓN CONSIDERANDO OPTIMIZACIÓN

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 Número de inserciones en el montículo para CPC utilizando el algoritmo iterativo HEAP, considerando y sin considerar técnicas de optimización.

Para el caso de K-CPC, las Tablas 6.18 y 6.19 muestran los resultados en base a estos dos parámetros 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 más pequeño en función de su área).


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 Tamaño máximo del montículo para K-CPC empleando el algoritmo iterativo HEAP, utilizando Fijar las Hojas (FH) y Fijar la Raíz (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 Número de inserciones en montículo para K-CPC empleando el algoritmo iterativo HEAP, utilizando Fijar las Hojas (FH) y Fijar la Raíz (FR).

De las tablas anteriores podemos comprobar que aplicar la técnica de Fijar la Raíz proporciona un sensible aumento del tamaño del montículo principal con respecto a aplicar Fijar las Hojas. Esto es debido a que el algoritmo debe procesar el R*-tree más grande hasta alcanzar la altura del más pequeño, y cuanto mayor sea la diferencia de altura, mayor será el número de pares de MBRs insertados en el montículo utilizando la técnica Fijar la Raíz. Por lo que respecta al número de inserciones, éste se ve considerablemente reducido al aplicar Fijar la Raíz, 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 más pequeño que si se procesan los dos R*-trees fijando las hojas, lo que provoca una notable reducción en el número de inserciones en el montículo mínimo principal.


Por último, el tiempo de respuesta (segundos) para los algoritmos recursivos e iterativos va a ser el siguiente parámetro a estudio considerando R*-trees con diferentes alturas y utilizando las dos técnicas presentadas para su procesamiento (FH y FR).

Capítulo 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

Tie

mpo

de

Res

pues

ta (

seg.

)

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 gráfica de barras de la Figura 6.9, podemos extraer varias conclusiones interesantes para CPC:

1. Los algoritmos recursivos son más rápidos que los iterativos, y la técnica Fijar las Hojas es mejor que aplicar Fijar la Raíz. La razón de esta diferencia radica fundamentalmente en la gestión extra que tienen que hacer los algoritmos iterativos sobre el montículo mínimo global de pares de MBRs.

2. En el algoritmo iterativo, utilizar la técnica Fijar la Raíz, es más 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 Raíz combinan más pares de MBRs fijando la raíz del R*-tree con menor altura, lo que supone un número mayor de cálculos de distancias entre MBRs.

3. PS es la variante con menor tiempo de respuesta debido a que el Barrido del Plano es una técnica pensada para optimizar este parámetro, ya que no considera la combinación de todas las entradas de un nodo con todas las del otro nodo, como hemos podido comprobar en el apartado 6.2.


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 más lentas, sobre todo si se aplica la técnica de Fijar la Raíz (cuanto mayor es el número de pares de MBRs que se combinan, mayor es el número 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 técnicas 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 técnicas 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 más suave y no tan pronunciada. Además, la mejor alternativa cuando los R*-trees tienen diferentes alturas es: Fijar las Hojas para los algoritmos recursivos, y Fijar la Raíz 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 actualización de distanciaPodaKCPC y KMasCercanos será más efectiva. Por otro lado, Fijar la Raíz es la mejor técnica para los iterativos, ya que, además de seguir una estrategia de búsqueda de primero el mejor sobre un montículo mínimo global para evitar la recursividad, cuantos más MBRs se combinen en niveles superiores, la actualización de distanciaPodaKCPC será mejor, y una vez alcanzado el nivel de las hojas, los mejores pares de objetos serán los primeros en obtenerse.

Capítulo 6

202

0

8

16

24

32

40

1 10 100 1000 10000 100000

Número de Pares

Tie

mpo

de

Res

pues

ta (

seg.

)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 conclusión más importante que podemos extraer de este conjunto de experimentos y añadir a las obtenidas en el apartado anterior es que para procesar R*-trees con diferentes alturas, Fijar las Hojas (FH) es la mejor técnica para el algoritmo recursivo, mientras que Fijar la Raíz (FR) lo es para los algoritmos iterativos. Además, la versión recursiva con Fijar las Hojas (FH) es la que proporciona los mejores resultados (número de accesos a disco y tiempo de respuesta) cuando K < 100000, mientras que cuando K ≥ 100000 lo es la versión iterativa (HEAP) combinado con la técnica Fijar la Raíz (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 parámetro hemos utilizado conjuntos de datos (puntos) de diferente naturaleza. Por un lado, puntos reales y reales movidos aleatoriamente, y por otro, sintéticos siguiendo una distribución uniforme y generados aleatoriamente. Todos ellos tienen idéntica 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%),


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%.


En primer lugar, mostramos los resultados de CPC, para el algoritmo recursivo (RECU) e iterativo (HEAP), con respecto al número de accesos a disco. La Tabla 6.22 representa dicha información 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 sintéticos obtenidos según una distribución 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 Número de accesos a disco para CPC sobre R*-trees procedentes de la indexación 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 Número de accesos a disco para CPC, utilizando R*-trees procedentes de la indexación de puntos sintéticos generados aleatoriamente y siguiendo una distribución uniforme.

Capítulo 6

204

0

5000

10000

15000

20000

25000

30000

35000

0% 3% 6% 12% 25% 50% 75% 100%

Porcentaje de Solape

Acc

esos

a D

isco

RECU_SIM RECU_STD RECU_PS HEAP_EXH

Figura 6.11 Número de accesos a disco para CPC para algoritmos recursivos e iterativos con

puntos aleatorio/uniforme.

Las conclusiones más 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 número de accesos a disco también crece. La razón 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 número valores de distancia MinMinDist entre MBRs igual a 0 o muy próxima a él. Esto provocará un incremento en el número de llamadas recursivas y en el número de pares de MBRs que se insertan en el montículo mínimo principal para los algoritmos recursivos e iterativos, respectivamente.

2. Las variantes del algoritmo iterativo encuentran la solución en un número 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 búsqueda que utilizan.

3. Del algoritmo recursivo, las versiones STD y STM son las que tienen un menor número 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 pequeño, proporciona los peores resultados). La razón de este mejor comportamiento es debido a la ordenación que se establece en función 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 según el número 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 número 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. También debemos destacar


205

que el coste relativo de la variantes STD y STM del algoritmo recursivo son prácticamente idénticos, puesto que ambos ordenan los pares de MBRs en base a MinMinDist (lista y montículo mínimo local, respectivamente), y por ello sólo vamos a considerar la alternativa STD.

0%3%6%12%25%50%75%100%

1

100

10000

1000000

85%

88%

91%

94%

97%

100%

Cos

te R

elat

ivo


# 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%

Cos

te R

elat

ivo


# 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%

Cos

te R

elat

ivo


# 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%

Cos

te R

elat

ivo


# 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 más grande, la influencia de MaxMaxDist para K-CPC deja de tener efecto.

Capítulo 6

206

2. RECU_STD es la versión 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 según MinMinDist supone un ahorro considerable cuando el porcentaje de solape es pequeño, para cualquier valor de K. Además, cuando el factor de solape y K son grandes, también se produce un ahorro importante en el número 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 número de accesos a disco en algunos casos. Este fenómeno 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á próximo al 100% y para cualquier valor de K, la consulta utilizando RECU_PS tiene un coste en número de accesos a disco muy parecido a RECU_EXH. El motivo de que porcentajes de solape bajos o nulos provoquen un número de accesos a disco para RECU_PS de aproximadamente el doble de RECU_EXH es porque aplicar la técnica de Barrido del Plano puede hacer que muchos nodos hoja se visiten más de una vez, ya que el pivote puede ser de un R*-tree (RP) o del otro (RQ) dependiendo del orden de los MBRs en el eje de barrido, mientras que con RECU_EXH el pivote es siempre del primer R*-tree (RP), lo que provoca una mejor actualización de la distancia del par de objetos situado en la raíz del montículo máximo 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 pequeño (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 prácticamente igual cuando K ≤ 1000), aunque ese aumento es menor cuando K es muy grande. Especial atención merece el caso en que las áreas que cubren los conjuntos estén totalmente solapados y K = 1000000, puesto que el coste de HEAP es del 52% con respecto a RECU_EXH. La razón de este mejor comportamiento del algoritmo iterativo con respecto a las variantes recursivas es fundamentalmente por la naturaleza del mismo, ya que la versión iterativa que utiliza un montículo mínimo 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 distribución 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 utilización de un path-buffer, elemento que, como comprobaremos posteriormente, beneficia en mayor medida a las variantes del algoritmo recursivo.


207


El tiempo de respuesta (segundos) para los algoritmos recursivos e iterativos va a ser el siguiente parámetro 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 indexación 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 más rápida tanto para el algoritmo recursivo como para el iterativo, ya que está diseñada 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 más rápida. Este último fenómeno se debe fundamentalmente a dos factores: el primero es porque sólo tenemos que calcular el par más cercano y para ello la versión recursiva siguiendo un recorrido en profundidad es mejor que utilizar un recorrido basado en una estrategia de búsqueda de primero el mejor utilizando un montículo mínimo, y el segundo es porque, cuanto más porcentaje de solape haya entre las áreas que cubren los conjuntos de datos, mayor será el número de pares de MBRs con MinMinDist igual o muy próximos a 0, que tendrán que almacenarse en el montículo mínimo 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 función de su MinMinDist tardan más tiempo en obtener la respuesta a la consulta, ya que realizar dichos cálculos y operaciones asociadas requieren un tiempo adicional, aunque beneficien el rendimiento respecto a otros parámetros como puede ser al número de accesos a disco.

Capítulo 6

208

0

0.5

1

1.5

2

2.5

0% 3% 6% 12% 25% 50% 75% 100%


Tie

mpo

de

Res

pues

ta (

seg.

)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 indexación 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 más representativas (EXH y SIM tienen valores muy próximos, al igual que sucede a STD y STM. Por este motivo sólo 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%



K = 100 0% 3% 6% 12% 25% 50% 75% 100%




209

K = 1000 0% 3% 6% 12% 25% 50% 75% 100%



K = 10000 0% 3% 6% 12% 25% 50% 75% 100%



K = 100000 0% 3% 6% 12% 25% 50% 75% 100%



K=1000000 0% 3% 6% 12% 25% 50% 75% 100%



Tabla 6.25 Tiempo de respuesta en segundos para K-CPC utilizando los algoritmos recursivos e iterativos, sobre R*-trees procedentes de la indexación 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 epígrafes 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 están 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.

Capítulo 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 también lo es (mayor al 75%), pero cuando el porcentaje de solape es pequeño para estos mismos valores de K, la variante ganadora es RECU_EXH. Esto es debido a la política de combinación de nodos que utiliza cada alternativa. La técnica de Barrido del Plano (el pivote varía de un R*-tree a otro según el orden de los MBRS en los nodos internos que intervienen en la combinación) tiene su mayor efecto sobre conjuntos de datos con alto porcentaje de solape de las áreas que los cubren, mientras que la combinación de todos con todos (el pivote es siempre del primer R*-tree) es mejor cuando éste es pequeño.

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 según su MinMinDist. Para este caso (K ≥ 100000), un resultado realmente interesante aparece en los algoritmos recursivos que no hacen uso de la ordenación 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 más pequeño (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 razón fundamental de que se produzca este comportamiento para RECU_STD es porque la ordenación de pares de MBRs según su MinMinDist detecta más rápidamente los pares con menor distancia, haciendo que el número de llamadas recursivas y actualizaciones del montículo máximo adicional KMasCercanos sea menor. Además, en los casos en que K ≤ 100 y el porcentaje de solape es pequeño, 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 más representativas de los algoritmos, siendo K igual a 10 y 1000000.


211

0

5

10

15

20

0% 3% 6% 12% 25% 50% 75% 100%


Tie

mpo

de

Res

pues

ta (

seg.

)

REXH RSTD RPS HEXH HSTD HPS

0

80

160

240

320

400

0% 3% 6% 12% 25% 50% 75% 100%


Tie

mpo

de

Res

pues

ta (

seg.

)

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 gráfica de la Figura 6.14 (K = 10, como ejemplo de una valor pequeño de K) podemos apreciar que las versiones iterativas son siempre sensiblemente mejores que sus homónimas 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 más rápidas. La tendencia general para este valor de K (10) es que conforme crece el porcentaje de solape, el coste en tiempo de respuesta también crece. Por otro lado, en la segunda gráfica (K = 1000000, ejemplo de valor muy grande de K), de forma general, el algoritmo iterativo es siempre notablemente más rápido 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 más costosa la consulta desde el punto de vista del tiempo de respuesta. Dicha tendencia también 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 fenómeno se debe fundamentalmente al gran número de llamadas recursivas y actualizaciones de KMasCercanos que tiene que hacer el algoritmo recursivo

Capítulo 6

212

cuando no se ordenan los pares de MBRs en función de su MinMinDist (hay que explorar uno a uno todos los posibles pares de MBRs generados de la combinación de los elementos de dos nodos internos).

Conclusiones

Las conclusiones más importantes que podemos extraer de este conjunto de experimentos y añadir 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 número de accesos a disco también crece, siendo el algoritmo iterativo (las versiones STD y STM del algoritmo recursivo tuvieron resultados muy próximos) el que proporciona un número 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 más rápida, 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 más rápidas.

6.5 Inclusión de un buffer de páginas con una política de reemplazo LRU

Leer datos directamente desde disco es más costoso que leerlos de un buffer de páginas almacenado en memoria principal. Por esta razón, una gestión adecuada de dicho buffer puede mejorar notablemente el rendimiento del sistema respecto al número de accesos a disco. Hasta el momento se han publicado muchos trabajos sobre la gestión de un buffer de páginas en un SGBD, donde se adaptan políticas de reemplazo utilizadas en sistemas operativos dependiendo de la disponibilidad de páginas en el buffer en tiempo de ejecución, entre ellos destaca [EfH84]. Por otro lado, otros estudios sobre la gestión del buffer están enfocados exclusivamente en patrones de acceso a consultas, siendo las contribuciones más importantes [ChD85, SaS82].

Buffers y políticas de reemplazo de página

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 razón, el efecto


213

de incluir un buffer de páginas debe considerarse como un factor importante a la hora de estudiar el procesamiento de consultas. En la Figura 6.15 se ilustra la arquitectura estándar de una base de datos para el procesamiento de consultas, donde BD es un conjunto de archivos binarios (almacenados en disco) divididos en páginas cuyos tamaños se establecen según determinados criterios en la creación de la base de datos (R*-trees RP y RQ), el Módulo de E/S se dedica a leer (escribir) páginas del (al) disco, el Gestor del Buffer trae (lleva) páginas almacenas en el Buffer Pool del (al) disco a través del Módulo de E/S, y el Procesador de Consultas soporta diferentes tipos de consultas sobre la Base de Datos.

Procesador

de ConsultasGestor del Buffer

Buffer Pool Módulo de E/S BD

Figura 6.15 Arquitectura estándar de una base de datos para el procesamiento de

consultas.

El objetivo principal de esta sección es determinar el efecto de incluir un buffer de páginas gestionado con una política de reemplazo de página como es LRU (Least Recently Used) para la consulta de los pares más cercanos donde los dos conjuntos de objetos espaciales están 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 páginas adicional para optimizar el número 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 están 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 optimización 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 evaluación de diferentes estrategias para realizar joins espaciales. En este caso, el gestor del buffer puede manejar varios buffers de páginas según una política LRU o FIFO, teniendo en cuenta que un archivo de datos o índice tiene asociado un solo buffer pero un buffer puede contener páginas de varios índices o archivos de datos. También 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, además de un path-buffer por cada árbol, un buffer local para cada uno de los índices gestionado con una política de reemplazo LRU y un FD-buffer que contiene los códigos 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 páginas almacenado en memoria principal. El buffer del sistema está controlado por el sistema operativo bajo una política LRU y éste no es desactivado. Por otro lado, tenemos el gestor de un buffer de páginas local a cada R*-tree manipulado según una política de reemplazo LRU y con un número de páginas determinado.

Capítulo 6

214

Los algoritmos de reemplazo de página más representativos son los siguientes. El algoritmo FIFO asigna prioridad a las páginas del buffer más jóvenes, reemplazando siempre la más antigua. El esquema LFU favorece las páginas más frecuentemente referenciadas y sustituye la página con frecuencia de acceso más baja. Gclock es una modificación de LFU que funciona de la siguiente forma: cuando ocurre una falta de página, reduce cíclicamente en 1 el contador de referencias de cada página 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 páginas más recientemente referenciadas, sustituyendo la menos recientemente utilizada. MRU es un esquema opuesto a LRU, sustituyendo la página más recientemente referenciada. El esquema LRU/2 es un caso particular del algoritmo LRU/K [OOW93], y reemplaza la página cuyo penúltimo acceso es el menos recientemente referenciado entre todos los penúltimos accesos. LRD [EfH84] no es una política de reemplazo basada en la permanencia de una página en el buffer, sino en su densidad de referencia desde la primera vez que fue accedida, sustituyendo la página con menor densidad de referencia cuando se produce una falta de página. En [PaM96] se propuso una política de reemplazo de página para bases de datos espaciales, denominada LRD-Manhattan, y que es una variante de LRD. En dicho algoritmo, cada página del buffer tiene asociado un MBR en el espacio Euclídeo 2-dimensional, cuando ocurre una falta de página, éste utiliza dos parámetros (densidad de referencia de página [EfH84] y el área del MBR vinculado a dicha página) para reemplazar la página del buffer con la mínima probabilidad de referencia.

Existen también esquemas de reemplazamiento de página híbridos que combinan dos políticas sencillas para gestionar la permanencia de páginas en el buffer. Estos esquemas consisten en dividir el buffer en dos regiones, un área para páginas frías que sólo se han referenciado una vez y otra área para páginas calientes con más de un acceso. Por ejemplo, en [BJK+97] la zona de páginas frías se gestiona con una política LRU, mientras que la parte de páginas calientes es tratada como FIFO. Sabiendo que cuando una página es re-referenciada y está en el área de páginas frías (LRU) pasa al área de páginas calientes (FIFO). Otra política híbrida, denominada 2Q [JoS94], gestiona el área de páginas frías como una cola FIFO y la de calientes como LRU.

Esquema de buffer Local

En esta sección experimental vamos a considerar uno de los casos propuestos en [CoS00, CVM01], donde el buffer de páginas tiene un tamaño B, está gestionado por un algoritmo de reemplazo de página LRU y sigue un esquema de buffer Local, en el que a cada R*-tree le vamos a asignar un número de páginas igual a B/2. En la Figura 6.16 podemos observar dicho esquema respecto a las consultas de los pares más cercanos (CPC y K-CPC). En esta gráfica RP y RQ son los dos R*-trees almacenados en disco y divididos en páginas cuyos tamaños se establecen según determinados criterios en la creación de los mismos; el Módulo de E/S se dedica en este caso a leer páginas del disco y no tenemos control sobre él; el Gestor del Buffer, siguiendo una política de reemplazo de página LRU, trae páginas almacenas en el Buffer Pool del disco a través del Módulo de E/S; y el Procesador de Consultas soporta en este caso las consultas de los pares más cercanos (CPC y K-CPC). También, debemos destacar la presencia en memoria de un path-buffer por cada R*-tree, donde están almacenados los nodos del camino actual en el recorrido del R*-tree asociado.


215

RP

Módulo de E/S

Buffer Local LRU (RP)

CPC/K-CPC

RQ

Buffer Local LRU (RQ)

Figura 6.16 Esquema de buffer Local para la consulta de los pares más cercanos.

La estructura general del buffer LRU de páginas 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 páginas de datos que se corresponden con un nodo (interno u hoja) del R*-tree. Para gestionar esta estructura de datos con una política de reemplazo LRU necesitamos un contador global, denominado lruCount, que se incrementa cada vez que la consulta requiere una página (referenciada por primer vez o re-referenciada). Para identificar a cada página necesitamos saber su número de registro absoluto en el archivo del índice (direccion), y el valor de lruCount que indica cuando dicha página fue referenciada por última vez (lruVal). Evidentemente, si queremos evitar recorrer todas las páginas del buffer cuando una página cualquiera es requerida, podemos incluir una tabla hash adicional organizada según el número de registro absoluto de las páginas en el archivo de índice, reduciendo el tiempo de respuesta de la consulta cuando hay un buffer LRU de gran tamaño.

0 1 2 3

···

B – 1

Páginas 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 páginas almacenado en memoria (buffer

pool).

Capítulo 6

216

El algoritmo de reemplazo de página LRU para la operación de lectura es el que vamos a utilizar en nuestros experimentos. Éste se basa en que las páginas que se han utilizado mucho en las últimas operaciones, probablemente se utilizarán mucho en las siguientes. Por otro lado, las páginas que hace mucho tiempo que no se utilizan, probablemente seguirán sin utilizarse durante largo tiempo. Esta idea sugiere un algoritmo sencillo: cuando ocurra una falta de página, se reemplazará la página del buffer que haya estado más tiempo sin utilizarse. Esta estrategia se denomina LRU (menos utilizada recientemente) y el algoritmo de reemplazo de página para la operación de lectura es el que se muestra a continuación:

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 = pi; 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;

Además de considerar un buffer LRU vinculado a cada R*-tree, le hemos asociado a cada de ellos un path-buffer, donde están almacenados los nodos del camino actual en el recorrido de cada R*-tree desde la raíz 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 están en él. Es decir, el nodo raíz 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 gestión del path-buffer es independiente del buffer LRU, aunque ambos estén 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 página de un determinado R*-tree, primero busca dicha página en el path-buffer asociado, y si la página deseada no se encuentra en éste, entonces busca en su buffer LRU, produciéndose una falta de página y el correspondiente acceso a disco si ésta no está presente.


217

R*-tree ···

Altura – 1

Path-Buffer

0

Altura – 2

Altura – 3

Nodo0

Nodo i i

NodoAltura-3

NodoAltura-2

Raíz = NodoAltura-1

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

Evaluación de los resultados

Para realizar los experimentos que muestren el comportamiento de los algoritmos (número de accesos a disco) ante la presencia de un buffer de páginas gestionado mediante una política de reemplazo LRU hemos utilizado los mismos conjuntos de datos que en experimentos anteriores, es decir, puntos reales y reales movidos aleatoriamente con idéntica cardinalidad (62556 puntos), dando lugar a R*-trees con la misma altura (4). También debemos indicar que los resultados de los experimentos sobre puntos sintéticos (uniformes y generados aleatoriamente) han seguido tendencias similares.

En primer lugar, merece especial atención considerar el efecto de incluir un path-buffer sobre los algoritmos recursivos e iterativos. Para CPC, la inclusión un path-buffer supone un ahorro del 30% en el número 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 más al algoritmo que sigue un recorrido en profundidad (recursivo), que al algoritmo que sigue una estrategia de búsqueda de primero el mejor utilizando un montículo mínimo 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.

Capítulo 6

218

Una vez visto el efecto de incluir un path-buffer, vamos a estudiar el ahorro de operaciones de E/S que supone añadir 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 Número de accesos a disco y porcentaje de ahorro del algoritmo recursivo (RECU_STD) respecto del iterativo (HEAP_STD) para CPC, utilizando un buffer de páginas de tamaño variable (0 ≤ B ≤ 1024) y gestionado con una política LRU.

En la Figura 6.19 podemos apreciar el efecto de incluir un buffer LRU con un tamaño variable de páginas (B, desde 0 hasta 1024) para la consulta del par más cercano (CPC) utilizando el algoritmo recursivo (RECU_STD) y el iterativo (HEAP_STD). En dicha gráfica podemos observar la diferencia que existe entre los dos algoritmos, siendo el recursivo, en promedio, un 10% mejor que el iterativo. La razón fundamental de esta diferencia radica en que un buffer de páginas con una política de reemplazo LRU (sustituye del buffer la página menos utilizada recientemente, dando más prioridad a las que tienen una referencia más reciente) mejora el rendimiento (número de operaciones de E/S) de un algoritmo que hace uso de la recursividad respecto a otro que la evita utilizando un montículo mínimo global combinado con una política de búsqueda de primero el mejor.

10000

14000

18000

22000

26000

30000

0 4 8 16 32 64 128 256 512 1024

Tamaño del Buffer (en Páginas)

Acc

esos

a D

isco

RECU_STD HEAP_STD

Figura 6.19 Efecto de incluir un buffer de páginas de tamaño variable al aplicar el

algoritmo recursivo (RECU_STD) y el iterativo (HEAP_STD) para obtener el par más cercano (CPC).

Una vez visto el comportamiento de los algoritmos para CPC ante la inclusión de un buffer de páginas gestionado con una política de reemplazo LRU, vamos a analizar el efecto que éste


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 término de accesos a disco es muy elevado y prácticamente el mismo para todos los valores de K. También 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 Número de accesos a disco del algoritmo recursivo (RECU_STD) para K-CPC utilizando un buffer de páginas LRU de tamaño variable (0 ≤ B ≤ 1024).

0 4 8 16 32 64 128 256 512 10241

100

10000

1000000

0

24000

48000

72000

96000

120000

Acc

esos

a D

isco

Tamaño del Buffer

# Pares

0-24000 24000-48000 48000-72000 72000-96000 96000-120000

Figura 6.20 Número de accesos a disco del algoritmo recursivo (RECU_STD) para K-

CPC utilizando un buffer de páginas LRU de tamaño variable.

Para el caso del algoritmo iterativo (HEAP_PS, variante iterativa con mejor comportamiento ante la presencia de un buffer LRU de gran tamaño), 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.

Capítulo 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 Número de accesos a disco del algoritmo iterativo (HEAP_PS) para K-CPC utilizando un buffer de páginas LRU de tamaño variable (0 ≤ B ≤ 1024).

0 4 8 16 32 64 128 256 512 10241

100

10000

1000000

0

15000

30000

45000

60000

75000

Acc

esos

a D

isco

Tamaño del Buffer

# Pares

0-15000 15000-30000 30000-45000 45000-60000 60000-75000

Figura 6.21 Número de accesos a disco del algoritmo iterativo (HEAP_PS) para K-CPC

utilizando un buffer de páginas LRU de tamaño variable.

De los datos de las Tablas 6.28 y 6.29 podemos extraer gráficas que representen el porcentaje de ganancia para K-CPC que supone incrementar el tamaño del buffer de páginas (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 tamaño 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 tamaño del buffer crece, el porcentaje de ahorro para el número de accesos a disco también se incrementa, aunque en menor medida que la variante recursiva, pero fijar un tamaño 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 tamaño del buffer es de 512 páginas 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).


221

481632641282565121024

1

100

10000

1000000

0%

20%

40%

60%

80%

100%

Por

cent

aje

de A

horr

o

Tamaño 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 tamaño del buffer (B > 0) con respecto a B = 0.

481632641282565121024

1

100

10000

1000000

0%

12%

24%

36%

48%

60%

Por

cent

aje

de A

horr

o

Tamaño 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 tamaño del buffer (B > 0) con respecto a B = 0.

Para finalizar esta sección, vamos a comparar la utilización del algoritmo recursivo (RECU_STD) y del iterativo (HEAP_STD), sobre la consulta de los K pares más cercanos (K-CPC) cuando tenemos presente un buffer LRU de tamaño fijo (B = 512). En la Tabla 6.30 podemos ver el número de accesos a disco (representado gráficamente 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%

Capítulo 6

222

cuando K = 100000 y del 79% cuando K = 1000000. Además, el incremento del valor de K no supone un gasto sustancial en el número de accesos a disco para el algoritmo recursivo cuando B = 512, sólo 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 número de operaciones de E/S con el mismo tamaño 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 Número de accesos a disco del algoritmo recursivo (RECU_STD) e iterativo (HEAP_PS) para K-CPC utilizando un buffer LRU de tamaño 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

Tamaño del Buffer (en Páginas)

Acc

esos

a D

isco

RECU_STD HEAP_PS

Figura 6.24 Número de accesos a disco para K-CPC utilizando los algoritmos, recursivo

(RECU_STD) e iterativo (HEAP_PS), fijando el tamaño del buffer (B = 512) y tomando como parámetro variable el valor de K.

A título de comentario podemos decir, que para estos experimentos hemos utilizado un esquema de buffer Local, en el que cada R*-tree tiene su fracción de buffer independiente y de igual tamaño. Aunque, también se podría haber empleado un esquema de buffer Global (Figura 6.25), donde los dos R*-trees comparten el buffer de páginas a nivel global y el path-buffer desaparece. En [CVM01] se sugiere este último esquema, ya que además de proporcionar resultados muy similares al esquema de buffer Local (en algunos casos, mejores), el Gestor del Buffer podría:

• Incluir y gestionar más de dos R*-trees en el mismo buffer de páginas.

• Dar mayor prioridad a algunos de los R*-trees que intervienen en la consulta.


223

• Gestionar y asignar dinámicamente más páginas a un determinado R*-tree, reduciendo el número de páginas que se la asignarán al otro.

• Introducir técnicas de optimización global para reducir aún más el número de accesos a disco.

RP

Módulo de E/S

CPC/K-CPC

RQ

Buffer Global LRU

Figura 6.25 Esquema de buffer Global para la consulta de los pares más cercanos.

Conclusiones

De los anteriores resultados podemos extraer las siguientes conclusiones respecto a la inclusión de buffers en la consulta de los pares más cercanos:

1. Incluir un path-buffer supone un mayor ahorro para el algoritmo recursivo que para el iterativo. La razón 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 expansión. En cambio, esto no ocurre en el algoritmo iterativo.

2. Evidentemente, cuanto mayor es el tamaño del buffer LRU (B), mayor es el ahorro de operaciones de E/S, utilizando cualquier algoritmo (recursivo o iterativo) para dar solución a K-CPC. Esto se debe a que mantener una parte del índice en memoria principal combinado con una política de reemplazo de página como es LRU (da prioridad a las páginas más recientemente referenciadas), reduce notablemente el número de accesos a disco.

3. De los resultados obtenidos podemos destacar que la influencia del esquema de buffering Local con una política de reemplazo LRU asociado a cada uno de los R*-trees afecta de forma más significativa a las variantes del algoritmo recursivo que a las del iterativo. La razón 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 más que al algoritmo que sigue una

Capítulo 6

224

estrategia de búsqueda basada en primero el mejor utilizando un montículo mínimo global para evitar la recursividad.

4. Con un tamaño de buffer fijo, el incremento del número 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, viéndose más favorecido el que sigue un recorrido en profundidad utilizando la recursividad, ya que empleando una política de reemplazo de página LRU, en la fase de backtracking las páginas referenciadas recientemente van a estar en el buffer con una gran probabilidad. En cambio, el algoritmo iterativo que utiliza un montículo mínimo global no sabe a priori, si la página a utilizar puede estar o no en el buffer.

6.6 Comparación con la alternativa incremental

Alternativa incremental. Características y algoritmos

Como hemos comentado en el capítulo 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 aplicación directa de esta operación es encontrar los K pares más 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 finalización 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 métodos multi-etapa, la técnica de Barrido del Plano y conceptos relacionados con el eje y dirección de barrido como criterios de optimización. Además, 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 Euclídea. En [HjS98] se presentan tres variantes del algoritmo, que se clasifican en función de la política 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 RP) 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 núcleo para su funcionamiento una cola de prioridad (implementada como un montículo mínimo), donde cada elemento es un par formado por un componente de RP y otro de RQ, es decir, tendremos pares de la forma: MBR/MBR, MBR/OBJ, OBJ/MBR y OBJ/OBJ. La clave


225

utilizada para ordenar los elementos en la cola de prioridad es la mínima 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 máxima 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 máxima necesaria para calcular los K pares más cercanos. No obstante, también se puede hacer uso de otros tipos de pares, como por ejemplo MBR/MBR, para llevar a cabo el mismo proceso. Si denotamos a Dmax como la distancia máxima impuesta sobre los pares (se irá actualizando durante el procesamiento del algoritmo), y a MaxMaxDist como la función 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 Dmax (fijada inicialmente a ∞) lo máximo posible dependiendo de K (número máximo de pares requeridos). Un par (MBRP, MBRQ) se elige para estimar Dmax si verifica que MaxMaxDist(MBRP, MBRQ) ≤ Dmax, garantizando que todos los pares OBJ/OBJ generados de (MBRP, MBRQ) tendrán una distancia en el rango [0, Dmax].

El proceso para ir actualizando Dmax (valor de distancia para que los pares que se vayan generando se inserten en la cola de prioridad cuando queremos determinar los K pares más cercanos) va a depender de K. Para poder llevar a cabo dicho proceso de actualización es necesario mantener un conjunto adicional de pares (MBRP, MBRQ), denominado M, que incluya cada uno de los pares que se han insertado en la cola de prioridad, pero no han sido procesados todavía. El procedimiento que actualiza M y Dmax tiene en cuenta los siguientes puntos:

• Cuando un par (MBRP, MBRQ) verifica que MinMinDist(MBRP, MBRQ) ≤ Dmax, éste se inserta en la cola de prioridad y también en M. Si la inserción 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 Dmax al valor de MaxMaxDist del último par borrado.

• Cuando un par (MBRP, MBRQ) se extrae de la cola de prioridad debe borrarse también de M, si está presente.

• Cuando devolvemos el siguiente par OBJ/OBJ más cercano, entonces se reduce el valor de K en uno.

Una pregunta clave que se plantea en [HjS98] es la siguiente: ¿cómo 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 simultáneamente, y para conseguirlo, en [HjS98] utilizan una cola de prioridad QM, implementada como un montículo máximo (en la raíz 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 según MaxMaxDist. Cada elemento de esta tabla hash contiene un puntero a la correspondiente entrada en la cola de prioridad QM, pudiendo eliminar de QM cualquier par de MBRs.

Capítulo 6

226

Como hemos indicado anteriormente, en la implementación de este algoritmo incremental, todos los posibles tipos de pares se insertan en la cola de prioridad principal, y el tamaño de ésta puede ser extraordinariamente grande dependiendo del tamaño de los árboles (RP y RQ). Por ello, en [HjS98], la cola de prioridad se almacena parcialmente en memoria principal (una parte es una cola de prioridad implementada como un montículo mínimo y la otra es una lista desordenada) y el resto en disco (como un conjunto de listas enlazadas basadas en distancias). La distinción del tamaño 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 accederán. El tamaño de cada parte está fuertemente condicionado por la elección de una constante denominada DT , que fragmenta la recta real en un número 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 idéntica cardinalidad (62556 puntos), dando lugar a R*-trees con la misma altura (4). En el apéndice A presentamos los seudo-códigos de los algoritmos incrementales [HjS98] implementados para esta comparación.

También, debemos indicar que los resultados obtenidos de aplicar los algoritmos incrementales para K-CPC son relativos a la finalización de los mismos (devolver los K pares más cercanos al final), aunque siguiendo su funcionamiento normal, el usuario puede disponer de parte del resultado durante la ejecución 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 número 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, según se indica en la Tabla 6.31. Para los algoritmos incrementales establecemos arbitrariamente DT = 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 Número 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).


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 número 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. También podemos destacar el elevado número de operaciones de E/S que tiene la variante BAS respecto a SML y HEAP_STD, siendo ésta, en promedio, el 85% más costosa. La variante RECU_STD tiene valores muy próximos a HEAP_STD para valores de K pequeños (K ≤ 1000), aunque la diferencia llega a ser del 20% para K = 100000.

Intentando reducir el número de accesos a disco, vamos a incluir un buffer LRU de 512 páginas, 256 para cada R*-tree, obteniendo los resultados que se muestran en la Tabla 6.32. En este caso, la variante STD de la versión 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 número de accesos a disco de RECU_STD respecto a SML y HEAP_STD es del 57% y 55%, respectivamente.


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 Número 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 páginas (B = 512).

En la Figura 6.26 se puede observar la tendencia de los algoritmos según el número de accesos a disco para K-CPC, destacando que en presencia de un buffer LRU, el gasto extra que supone obtener el par más cercano o los 100000 pares más 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 número menor de accesos a disco (ahorro del 8% al 5%). Además, entre RECU_STD y SML existe una diferencia del 57% como gasto adicional para obtener los 100000 pares más cercanos, siendo sólo del 14% cuando K = 1. Con estos resultados podemos confirmar la gran influencia que tiene un buffer de páginas almacenado en memoria principal sobre el algoritmo recursivo, produciéndose un ahorro del 83% para K = 100000, de no tener buffer (B = 0) a tener 512 páginas (B = 512) de buffer gestionadas con una política de reemplazo LRU con un esquema Local.

Capítulo 6

228

10000

24000

38000

52000

66000

80000

1 10 100 1000 10000 100000

Número de Pares

Acc

esos

a D

isco


Figura 6.26 Número 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 páginas.

Otros parámetros que merecen ser estudiados son la memoria principal requerida por los algoritmos iterativos y el número de inserciones en la cola de prioridad principal de los algoritmos incrementales y en el montículo mínimo global para los no incrementales (independientemente del tamaño del buffer LRU). Para comparar la memoria ocupada por las estructuras de datos (montículos) 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 número máximo de elementos en la cola de prioridad en memoria principal según el valor de DT . Debemos recordar, como característica 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 montículo mínimo sólo hay pares de la forma: MBR/MBR. En la Tabla 6.33 mostramos el número máximo de pares en la cola de prioridad (incrementales) y montículo mínimo (no incrementales), ambos inicializados con el mismo tamaño, destacando que debe existir una cola de prioridad (QM) adicional (implementada como un montículo máximo y organizado según MaxMaxDist) de tamaño variable según el valor de K para los algoritmos incrementales y de tamaño K (KMasCercanos, que es donde se almacena el resultado final) para los no incrementales. En dicha tabla podemos observar que el número 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 razón de este comportamiento en SML se debe fundamentalmente a que cuando K crece, el número de pares en la cola de prioridad en memoria también aumenta, aunque en disco se hayan almacenado muchos de ellos que no ha sido necesario utilizarlos. Además, cuando K ≥ 10000, los pares que se almacenan en disco se emplean durante el procesamiento del algoritmo con el objetivo de obtener los pares más cercanos deseados.


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 Número máximo 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 número de inserciones en la cola de prioridad y en el montículo 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 número 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 parámetros 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 Número de pares insertados en la cola de prioridad de los algoritmos incrementales y en el montículo mínimo principal de los no incrementales e iterativos en su variante STD, para K-CPC.

A continuación vamos a comparar el tiempo total de respuesta (segundos) requerido para poder llevar a cabo la consulta. Para ello, vamos a utilizar los mismos parámetros experimentales que hemos fijado para realizar las comprobaciones anteriores y un buffer LRU de 512 páginas, 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.

Capítulo 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 indexación de puntos reales y reales movidos aleatoriamente, y utilizando un buffer LRU de 512 páginas.

El aspecto más 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 finalización del mismo. La razón de este valor tan grande es fundamentalmente por el elevado número de inserciones y extracciones que se deben hacer sobre la cola de prioridad principal y en la auxiliar (QM), además del tiempo requerido para almacenar la fracción de pares en disco (parte de la cola de prioridad). También podemos observar que RECU_PS es la variante más rápida 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 según el tiempo de respuesta requerido por K-CPC medido en segundos.

0

18

36

54

72

90

1 10 100 1000 10000

Número de Pares

Tie

mpo

de

Res

pues

ta (

seg.

)

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 páginas.

En la gráfica 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 pequeños y medios (K ≤ 1000), la mejor alternativa es EVN (del 50% al 17% más rápida que


231

SML), pero cuando K se hacer mayor, SML resulta ser más rápida (del 2% al 25%). Si comparamos SML con las variantes no incrementales, la versión recursiva (RECU_PS) resulta ser del 90% al 99% más rápida para valores de K ≤ 10000, y la iterativa (HEAP_PS) del 84% al 99%. Evidentemente, para K = 100000 las versiones no incrementales son mucho más rápidas, 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 más cercanos es realmente una operación costosa. De los resultados obtenidos experimentalmente en esta sección 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 número de accesos a disco, motivado fundamentalmente por la combinación de la recursividad con buffer de páginas gestionado con una política 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. También debemos recordar que en ausencia de buffer, los algoritmos iterativos, incremental (SML) y no incremental (HEAP_STD), fueron los mejores y con el mismo número de operaciones de E/S necesarias para completar la consulta.

2. Si comparamos sobre los algoritmos iterativos, el número de pares que deben almacenarse en la estructura de datos que se utiliza para evitar la recursividad (cola de prioridad y montículo mínimo) y el número de inserciones en ella, que los algoritmos incrementales requieren una mayor cantidad de ambos parámetros, 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 sólo se insertan pares de la forma MBR/MBR. Además, debemos indicar que los incrementales, en base a estos dos parámetros, 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 más cercanos, claramente las alternativas incrementales no son competitivas respecto a las no incrementales (PS es la mejor variante para la evaluación de este parámetro), incluso cuando K es pequeño. 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 más rápida cuando K ≤ 10000, pero cuando K ≥ 100000 la alternativa iterativa y no incremental (HEAP_PS) proporciona los mejores resultados.

Capítulo 6

232

6.7 Auto-CPC y Semi-CPC

Dos de las extensiones más importantes de la consulta de los pares más cercanos son las que denominamos Auto-CPC y Semi-CPC. Auto-CPC es una extensión en el sentido de que los dos conjuntos de objetos de entrada para la consulta son idénticos P = Q, con lo que sus R*-trees también coincidirán, RP = RQ. Por otro lado, Semi-CPC tiene como característica principal que, dados los dos conjuntos de objetos P y Q, ésta calcula para cada objeto de P el objeto más próximo en Q.

Evaluación 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 parámetros de evaluación, el número 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 más representativas de los algoritmos recursivos e iterativos, sin utilizar y utilizando un buffer LRU de 512 páginas (256 para cada R*-tree). Por otro lado, en Figura 6.28, podemos observar la tendencia de la mejor variante (STD) ante el número 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 Número de accesos a disco de las mejores variantes de los algoritmos recursivos e iterativos, para Auto-K-CPC, en ausencia buffer.


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 Número de accesos a disco de las mejores variantes de los algoritmos recursivos e iterativos, para Auto-K-CPC, utilizando un buffer LRU con 512 páginas.

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 número de accesos a disco al tener que detectar y después descartar los pares iguales y los simétricos, haciendo uso de una tabla hash (Auto_Tabla_Hash) asociada al montículo máximo


233

que almacena el resultado (KMasCercanos). También, podemos apreciar la influencia de un buffer gestionado con una política de reemplazo de página LRU, sobre todo con las variantes recursivas. Por ejemplo, para K = 1000 y RECU_STD, de utilizar un buffer de 512 páginas a no utilizarlo se produce un ahorro del 62% en el número de accesos a disco.

La tendencia que se muestra en la Figura 6.28 es muy similar a la obtenida para K-CPC, pudiéndose apreciar la diferencia que existe en el número de accesos a disco provocado por la presencia de un buffer LRU.

10000

22000

34000

46000

58000

70000

1 10 100 1000 10000 100000

Número de Pares

Acc

esos

a D

isco

RECU_STD (0) HEAP_STD (0) RECU_STD (512) HEAP_STD (512)

Figura 6.28 Número de accesos a disco de la variante STD en los algoritmos recursivo e iterativo, para Auto-K-CPC, utilizando un buffer LRU con 512 páginas y en ausencia del

mismo.

El segundo parámetro 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 páginas, 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% más rápida.


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 páginas (256 para cada uno de los árboles).

Capítulo 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 más rápida es HEAP_PS.

0

20

40

60

80

100

1 10 100 1000 10000 100000

Número de Pares

Tie

mpo

de

Res

pues

ta (

seg.

)

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 páginas.

Evaluación de resultados para Semi-CPC

Una vez estudiada la extensión 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 capítulo 5 para Semi-CPC, GlobalObjetos (GO) y GlobalTodos (GT). Para comparar las adaptaciones anteriores, se ha implementado la forma más intuitiva de llevar a cabo la Semi-CPC y que denominamos R+CVP. Ésta consiste en recorrer el R*-tree RP (indexando al conjunto de objetos P) y ejecutar por cada elemento en las hojas del mismo, una consulta del vecino más próximo en el R*-tree RQ (indexando al conjunto de objetos Q), tomando a éste como elemento de consulta. La Tabla 6.39 muestra el número de accesos a disco en presencia de un buffer LRU de 512 páginas 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 Número 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 páginas.


235

De los datos de la tabla anterior se puede apreciar que esta consulta es bastante costosa respecto al número de operaciones de E/S. En ausencia de buffer, GO_RECU_SIM es la variante más 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 relación a GO_RECU_SIM. En presencia de un buffer LRU de 512 páginas 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 número de accesos del 29% menor que GT_RECU_STD. Esto se debe fundamentalmente a que, ejecutando un gran número de consultas del vecino más próximo sucesivamente (tantas como elementos de P) sobre un R*-tree (RQ) y la existencia de numerosas páginas en un buffer LRU, es muy probable que páginas muy accedidas de RQ se encuentren en dicho buffer, reduciendo notablemente el número 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 páginas.

Resulta interesante observar que R+CVP es la alternativa con menor tiempo de respuesta requerido para realizar la consulta (un 64% más rápida 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 más tiempo requiere (casi 10 veces más lenta que R+CVP), debido principalmente a la gran cantidad de accesos a disco que tiene que emplear para realizar la consulta. También podemos apreciar que con la presencia de un buffer LRU, se reduce el tiempo de respuesta además del número de accesos a disco. Por ejemplo, para R+CVP supone un ahorro de aproximadamente el 20%.

Conclusiones

La conclusión más 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 número 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 parámetros, sobre todo para el algoritmo recursivo en su variante PS (RECU_PS), sin olvidar que para K ≥ 100000, HEAP_PS fue la variante más rápida. Por otro lado, para Semi-CPC, la extensión del algoritmo iterativo para GlobalTodos y en ausencia de buffer la hacen bastante competitiva, pero cuando tenemos un

Capítulo 6

236

buffer LRU de un número razonable de páginas, la alternativa R+CVP es la que proporciona los mejores resultados.

6.8 Conclusiones de la experimentación

En este capítulo se han descrito los aspectos más relevantes del trabajo experimental desarrollado como justificación de las aportaciones de esta tesis. Debemos destacar también que no es objetivo de este trabajo de investigación exponer la implementación de los algoritmos, ni las de todas las estructuras de datos empleadas, que han sido muchas, ya que implicaría un considerable incremento en extensión 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 algorítmica para dar respuesta a la consulta del par más cercano o para cualquiera de sus extensiones en función de determinados parámetros, hemos desarrollado un amplio estudio comparativo. Esta labor de experimentación abarca desde la definición y generación de las distintas baterías de pruebas para los diferentes casos de estudio hasta el posterior tratamiento y evaluación de los resultados obtenidos.

Las conclusiones más importantes que hemos extraído de los experimentos son las siguientes:

1. Respecto a la evaluación experimental sobre K-CPC y CPC como un caso especial, obtenemos que:

1.1. En ausencia de buffer, la mejor alternativa respecto al número de accesos a disco es el algoritmo branch-and-bound iterativo, utilizando un montículo mínimo global para evitar la recursividad y combinado con una estrategia de búsqueda 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 combinación de la recursividad (recorrido en profundidad) con la gestión del buffer con una política de reemplazo LRU (da prioridad a las páginas más recientemente referenciadas).

1.2. Respecto al tiempo global requerido para realizar las consultas, la variante PS (optimización utilizando la técnica de Barrido del Plano) recursiva (RECU) de nuestros algoritmos branch-and-bound es la más rápida, aunque para valores de K muy grandes su homónima (PS) del algoritmo iterativo (HEAP) tiene un mejor comportamiento ante este parámetro.

1.3. Aplicar la métrica MinMaxDist en CPC y MaxMaxDist en K-CPC no supone un ahorro significativo respecto al número de accesos a disco para nuestros algoritmos branch-and-bound. Además, el cálculo de estas métricas y el procesamiento adicional necesario sobre estructuras de datos adicionales supone un gasto extra de CPU, haciendo que los algoritmos sean más lentos.


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 métrica MaxMaxDist (con un montículo máximo adicional) y una política 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 cálculo.

1.5. Cuando tenemos R*-trees con diferentes alturas, la técnica de Fijar las Hojas es la mejor para el algoritmo recursivo, mientras que Fijar la Raíz lo es para la versión iterativa. Además, la versión iterativa (HEAP) con Fijar la Raíz es la que proporciona los mejores resultados (número de accesos a disco y tiempo de respuesta) cuando K es muy grande, siendo en los otros casos la versión recursiva (RECU) combinada con la técnica 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 número de accesos a disco también crece, motivado fundamentalmente por la potencial existencia de un número mayor de pares de MBRs con MinMinDist igual a 0 ó muy próximos a este valor.

2. Si comparamos nuestros algoritmos no incrementales con los incrementales respecto a K-CPC llegamos a la conclusión de que la variante Simultaneous de estos últimos es la única competitiva para valores de K pequeños, pero nunca consigue aproximarse a los resultados de nuestros algoritmos recursivos en lo que respecta al número de accesos a disco y al tiempo de respuesta cuando K tiene valores medios y grandes. Además, 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. También 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 ejecución 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 número 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 más rápida. En cambio, para Semi-CPC, la extensión de nuestros algoritmos (recursivos e iterativos) para GlobalObjetos y GlobalTodos, además 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 más próximo sobre el segundo) cuando tenemos un buffer LRU de un número razonable de páginas.

Como conclusión final podemos decir que nuestro algoritmo branch-and-bound recursivo y no incremental (RECU), optimizado con la técnica del Barrido del Plano (PS), utilizando buffers adicionales (path-buffer y buffer LRU) y la política Fijar las Hojas para el tratamiento de árboles con diferentes alturas, es el más eficiente de todos, tanto desde el punto de vista del

Capítulo 6

238

tiempo de respuesta requerido como del número de operaciones de E/S empleadas, para realizar la consulta que obtiene los K pares más cercanos (K-CPC) de dos conjuntos de objetos de naturaleza espacial indexados por sendos R*-trees.

239

Capítulo 7

CONCLUSIONES Y TRABAJO FUTURO

Una vez expuestos los planteamientos fundamentales que sustentan esta tesis, llega el momento de recapitular acerca del contenido global de la misma y de orientar futuras tareas de investigación en el campo relativo a los algoritmos para el procesamiento y optimización de consultas espaciales. Con este objetivo, desarrollamos el presente capítulo, tratando de dejar claro, por una parte, las conclusiones más relevantes del trabajo de investigación realizado, y por otra, las líneas de acción futuras que constituirán la continuación de la labor desarrollada durante estos últimos años.

7.1 Conclusiones

En el desarrollo de la presente tesis hemos descrito los algoritmos utilizados para realizar las consultas espaciales más representativas sobre un método de acceso multidimensional muy estudiado, el R*-tree. Entre ellas destaca la consulta del par más cercano y todas sus extensiones. De toda la labor realizada a lo largo del tiempo de preparación de este trabajo, que concluimos con este capítulo resumen, podemos extraer como principales conclusiones las que enumeramos a continuación:

1. Los requerimientos de aplicaciones actuales de bases de datos, tales como GIS (sistemas de información geográfica), CAD (diseño asistido por ordenador), multimedia, etc., imponen la necesidad de encontrar algoritmos para dar respuesta de forma eficiente a consultas que expresen la relación basada en distancias que existe entre los datos a procesar. En dicho contexto, esta tesis contribuye a la aportación de algoritmos para resolver una nueva consulta espacial que consiste en la obtención de los pares más

Capítulo 7

240

cercanos de dos conjuntos de objetos indexados en estructuras de datos arbóreas basadas en MBRs y balanceadas en altura, que se encuentran almacenadas en disco (R*-trees).

2. El procesamiento eficiente de consultas sobre métodos de indexación espaciales (como los R*-trees) es un tema de investigación de gran importancia en la actualidad, provocado principalmente por las exigencias en la gestión de grandes volúmenes de datos en numerosas aplicaciones. Los algoritmos que actúan sobre estos métodos de indexación se basan en recorridos sobre dichos índices, combinados con propiedades intrínsecas a las consultas y mejorados normalmente con técnicas basadas en geometría computacional. En este ámbito, esta tesis recopila los algoritmos sobre R*-trees para resolver las consultas espaciales más relevantes y utilizadas.

3. La consulta del par más cercano y todas sus extensiones son de gran utilidad para muchas aplicaciones, sobre todo las que gestionan información espacial. Esta consulta obtiene la proximidad entre los elementos de dos conjuntos de objetos, en el mismo sentido que la consulta del vecino más próximo lo hace entre un objeto dado y un conjunto de objetos. Para resolver esta consulta proponemos unas métricas basadas en distancias entre pares de MBRs como base de heurísticas de poda que aplicamos en algoritmos branch-and-bound recursivos e iterativos.

4. Cuando se diseña un algoritmo para dar solución a un determinado problema, es necesario optimizarlo aplicando las técnicas más apropiadas para hacerlo lo más eficiente posible, y tratar de extenderlo para que resuelva otros problemas estrechamente relacionados. Nosotros aplicamos técnicas para optimizar algoritmos branch-and-bound recursivos e iterativos que obtienen el resultado de la consulta del par más cercano de dos conjuntos de objetos indexados en sendos R*-trees, en términos del número de accesos a disco (influencia de buffers) y del tiempo de respuesta (aplicación de la técnica de Barrido del Plano), principalmente. Además, extendemos dichos algoritmos para consultas muy similares como pueden ser, entre otras, la consulta de los K pares más cercanos (K-CPC), la Auto-CPC y Semi-CPC.

5. El trabajo efectuado en la implementación de todos los algoritmos branch-and-bound que se presentan en esta tesis y su evaluación sobre datos de naturaleza espacial, nos permiten aportar resultados muy interesantes respecto al rendimiento de los mismos. En este aspecto, estudiamos el comportamiento de todos nuestros algoritmos desde el punto de vista del número de accesos a disco y tiempo de respuesta (parámetros muy importantes en un sistema de gestión de bases de datos), y lo comparamos con las alternativas incrementales existentes. Las conclusiones que se derivan de los resultados experimentales son las siguientes:

5.1. La heurística de poda basada en MinMinDist es la realmente eficiente al aplicarla en algoritmos branch-and-bound para la consulta de los pares más cercanos y sus extensiones. Por otro lado, el utilizar la métrica MinMaxDist en CPC y MaxMaxDist en K-CPC no supone un ahorro significativo respecto al número de accesos a disco. Además, el cálculo de estas últimas métricas (MinMaxDist y MaxMaxDist) y el procesamiento adicional necesario sobre estructuras de datos adicionales supone un gasto extra de CPU, haciendo que los algoritmos sean más lentos.

Conclusiones y trabajo futuro

241

5.2. En ausencia de buffers los algoritmos branch-and-bound iterativos para K-CPC son los que proporcionan los mejores resultados según el número de accesos a disco. Pero al incluir buffers la versión recursiva de los mismos es la que presenta un mayor ahorro respecto a la actividad de E/S.

5.3. Respecto al tiempo de respuesta para K-CPC, la técnica de Barrido del Plano aplicada a nuestros algoritmos es la que optimiza este parámetro. La versión recursiva es la más rápida para valores de K pequeños y medianos, pero cuando tenemos valores grandes de K la versión iterativa requiere menos tiempo para completar la consulta.

5.4. Los algoritmos branch-and-bound iterativos (utilizando un montículo mínimo global y un recorrido basado en una función de selección de primero el mejor) para K-CPC requieren estructuras de datos adicionales para evitar la recursividad, y conforme crece el valor de K, los recursos necesarios también aumentan. Hemos propuesto técnicas que reducen estos recursos a costa de requerir un tiempo extra para completar la respuesta.

5.5. También hemos considerado el caso de que los árboles que intervienen en la consulta puedan tener diferentes alturas, proponiendo para este caso dos técnicas: Fijar las Hojas y Fijar la Raíz. Hemos podido comprobar que la técnica Fijar las Hojas es la más apropiada para el algoritmo recursivo, mientras que Fijar la Raíz lo es para la versión iterativa.

5.6. Si comparamos nuestros algoritmos no incrementales con los incrementales para K-CPC, llegamos a la conclusión de que nuestra versión recursiva es considerablemente mejor que la alternativa incremental más competitiva, respecto al número de accesos a disco y al tiempo de respuesta. En este sentido, debemos indicar que para obtener el resultado de K-CPC hemos omitido la característica principal de los algoritmos incrementales: el usuario puede disponer de parte del resultado de la consulta durante la ejecución de los mismos.

5.7. La extensión de nuestros algoritmos propuesta para Auto-K-CPC es apropiada, ya que obtiene resultados interesantes respecto a los parámetros principales a evaluación. En lo que respecta al tiempo de respuesta, la versión recursiva obtiene los mejores resultados para valores de K pequeños y medianos, mientras que si estos valores son grandes la versión iterativa es la más rápida. Al evaluar la actividad de E/S, si utilizamos buffers, la versión recursiva es la que proporciona un número menor de accesos a disco, mientras que en ausencia de buffers, el algoritmo iterativo es la mejor alternativa.

5.8. Por otro lado, si adaptamos nuestros algoritmos para obtener los resultados de Semi-CPC, además de consumir muchos recursos de memoria principal para completar la consulta, se obtienen peores resultados que combinar un recorrido en profundidad en el primer árbol con una consulta del vecino más próximo sobre el segundo, respecto al tiempo de respuesta y número de accesos a disco en presencia de buffers.

La experiencia acumulada durante el periodo de investigación en este campo nos permite asegurar que las propuestas que presentamos representan soluciones viables y eficientes a la

Capítulo 7

242

consulta de los pares más cercanos y sus extensiones sobre métodos de indexación espaciales basados en MBRs. La extensa fase experimental del presente trabajo de investigación que materializamos en esta tesis, confirma todas nuestras suposiciones sobre los beneficios de aplicar algoritmos branch-and-bound sobre estructuras de indexación espaciales, e induce a concebir fundadas esperanzas en los futuros trabajos en esta línea de investigación.

7.2 Líneas de trabajo futuro

Durante el desarrollo de esta tesis, hemos identificado las diferentes vías de solución para aquellos problemas que no son abordados directamente en esta memoria, pero están estrechamente relacionados con la línea de investigación en la que ésta se ubica. En este apartado, resumimos a grandes rasgos los trabajos que, incluidos en el ámbito de esta tesis, tenemos previsto desarrollar en un futuro inmediato.

1. Extender la consulta del par más cercano para soportar múltiples R*-trees de entrada, con el objetivo de obtener las tuplas más cercanas entre sí, siendo la consulta núcleo de esta tesis un caso particular de ésta. Este trabajo iría en la línea de los recientes artículos sobre join espacial ante múltiples R-trees de entrada [MaP98, MaP99, MaP00, PMT99, PCC99].

2. Desarrollo de un modelo de coste para la consulta de par más cercano desde el punto de vista de operaciones de E/S, en la misma línea que lo hacen [BBK+97, PaM97] para la consulta del vecino más próximo y, [HJR97b, TSS98, TSS00] para el join espacial, utilizando R-trees. Para estimar el coste de la consulta es necesario tener en cuenta el efecto del buffer (demostrado en la fase experimental), igual que se tiene en cuenta en [LeL98] para la consulta en rango sobre R-trees.

3. Otro trabajo a desarrollar dentro de esta misma línea sería aplicar nuestra consulta sobre objetos geométricos complejos, no sólo a puntos. Es decir, afrontar la fase de refinamiento en una consulta sobre índices, y no sólo la etapa de filtrado. Para ello, debemos estudiar aspectos importantes de geometría computacional en [BGH+99, ChN97, GRS95, MeN95].

4. Estudio del comportamiento de la consulta del par más cercano y sus extensiones ante datos de grandes dimensiones (vectores de características extraídos de objetos y estudio de la relación entre ellos) [CRV01]. Para poder realizar este estudio necesitamos implementar estructuras de datos arbóreas basadas en MBRs cuya eficiencia esté contrastada en consulta en rango y del vecino más próximo. Entre estos nuevos índices nos podemos encontrar al X-tree [BKK96], al SR-tree [KaS97], y al A-tree [SYU+00], entre otros. Además, compararíamos este comportamiento sobre algoritmos que no utilizan índices para K-CPC en la misma línea que [KoS98] y utilizando técnicas de geometría computacional [BKO+99, Oro98]. También, podríamos aplicar algoritmos branch-and-bound aproximados [Iba87] a datos multidimensionales indexados en índices arbóreos basados en MBRs, en la misma línea que en geometría computacional

Conclusiones y trabajo futuro

243

se hace para la consulta del vecino más próximo [ArM93, AMN+94, AMN+98] y de los puntos más cercanos [Cla94].

5. Otro posible trabajo podría ser, encontrar los pares más cercanos entre diferentes estructuras de datos almacenando información espacial y que pueden coexistir en el mismo sistema de base de datos espacial, como el caso de los R-trees y los Quadtrees de Regiones Lineales (Linear Region Quadtrees), basándonos en nuestro trabajo sobre join espacial entre estos dos tipos de estructuras de acceso [CVM99].

Todas estas tareas que se proponen como trabajo futuro se enmarcan dentro de la línea de investigación relacionada con el procesamiento y optimización de consultas sobre métodos de acceso espaciales, un tema de gran interés, tanto desde el punto de vista de crear estructuras de datos cada vez más eficientes como desde la perspectiva de incorporar nuevas técnicas algorítmicas para optimizar los algoritmos sobre dichas consultas.

Las enumeradas son sólo algunas de las posibles líneas de trabajo a seguir, y es que, ante esta nueva consulta con una aplicación realmente amplia, ... “quedan muchas cosas por hacer”.

245

REFERENCIAS

[Abe84] D.J. Abel; “A B+-tree Structure for Large Quadtrees”. Computer Vision, Graphics and Image Processing, Vol. 27, Nº 1. pp. 19-31. 1984.

[Abe89] D.J. Abel; “SIRODBMS: A Database Toolkit for Geographical Information Systems”. International Journal of Geographical Information Systems, Vol. 3, Nº 2. pp. 103-116. 1989.

[ACP+99] P. Atzeni, S. Ceri, S. Paraboschi y R. Torlone; “Database Systems. Concepts, Languages and Architectures”. McGraw-Hill Companies Inc. 1999.

[AMN+94] S. Arya, D.M. Mount, N.S. Netanyahu, R. Silverman y A.Y. Wu; “An Optimal Algorithm for Approximate Nearest Neighbor Searching”. ACM-SIAM Symposium on Discrete Algorithms (SODA’94). pp. 573-582. 1994.

[AMN+98] S. Arya, D.M. Mount, N.S. Netanyahu, R. Silverman y A.Y. Wu; “An Optimal Algorithm for Approximate Nearest Neighbor Searching Fixed Dimensions”. Journal of the ACM (JACM), Vol. 45, Nº 6. pp. 891-923. 1998.

[APR+98] L. Arge, O. Procopiuc, S. Ramaswamy, T. Suel y J. S. Vitter; “Scalable Sweeping-Based Spatial Join”. International Conference on Very Large Data Bases (VLDB’98). pp. 570-581. 1998.

[ArM93] S. Arya y D.M. Mount; “Approximate Nearest Neighbor Queries in Fixed Dimensions”. ACM-SIAM Symposium on Discrete Algorithms (SODA’93). pp. 271-280. 1993.

[ArS91] W.G. Aref y H. Samet; “Extending a DBMS with Spatial Operations”. Advances in Spatial Databases (SSD’91), Lecture Notes in Computer Science (Springer), Vol. 525. pp. 299-318. 1991.

[Ast00] O.L. Astrachan; “A Computer Science Tapestry. Exploring Programming and Computer Science with C++”. MacGraw Hill. 2000.

[BaM72] R. Bayer y E.M. McCreight; “Organization and Maintenance of Large Ordered Indices”. Acta Informatica, Vol. 1, Nº 3. pp. 173-189. 1972.

Referencias

246

[Bar96] M. Barrena; “Técnicas de Particionamiento Multidimensional Basadas en Índices Multiatributo en Bases de Datos Paralelas”. Tesis Doctoral, Universidad Politécnica de Madrid (España). 1996.

[BBJ+00] S. Berchtold, C. Böhm, H.V. Jagadish, H.P. Kriegel y J. Sander; “Independent Quantization: An Index Compresión Technique for High-Dimensional Data Spaces”. International Conference on Data Engineering (ICDE’00). pp. 577-588. 2000.

[BBK+97] S. Berchtold, C. Böhm, D.A. Keim y H.P. Kriegel; “A Cost Model for Nearest Neighbor Search in High-Dimensional Data Space”. ACM SIGACT-SIGMOD-SIGART Symposium on Principles of Database Systems (PODS’97). pp. 78-86. 1997.

[BBK98] S. Berchtold, C. Böhm y H.P. Kriegel; “The Pyramid-Tree: Breaking the Curse of Dimensionality”. ACM SIGMOD Conference (SIGMOD’98). pp. 142-153. 1998.

[Bec92] L. Becker; “A New Algorithm and a Cost Model for Join Processing with Grid Files”. PhD Dissertation, Universität-Gesamthochschule-Siegen (Alemania). 1992.

[Ben75] J.L. Bentley; “Multidimensional Binary Search Trees Used for Associative Searching”. Communications of ACM, Vol. 18, Nº 9. pp. 509-517. 1975.

[BeS76] J.L. Bentley y M.I. Shamos; “Divide-and-Conquer in Multidimensional Space”. Annual Symposium on Theory of Computing. pp. 220-230. 1976.

[Bes95] S.N. Bespamyatnikh; “An Optimal Algorithm for Closest Pair Maintenance”. Symposium on Computational Geometry, pp. 152-161, 1995.

[BGH+99] L. Becker, A. Giesen, K. Hinrichs y J. Vahrenhold; “Algorithms for Performing Polygonal Map Overlay and Spatial Join on Massive Data Sets”. Advances in Spatial Databases (SSD’99), Lecture Notes in Computer Science (Springer), Vol. 1651. pp. 270-285. 1999.

[BHK+93] T. Brinkhoff., H. Horn, H.P. Kriegel y R. Schneider; “A Storage and Access Architecture for Efficient Query Processing in Spatial Database Systems”. Advances in Spatial Databases (SSD'93), Lecture Notes in Computer Science (Springer), Vol. 692. pp. 357-376. 1993.

[BJK+97] W. Bridge, A. Joshi, M. Keihl, T. Lahiri, J. Loaiza y N. MacNaughton; “The Oracle Universal Server Buffer”. International Conference on Very Large Data Bases (VLDB’97). pp. 590-594. 1997.

[BKK96] S. Berchtold, D.A. Keim y H.P. Kriegel; “The X-tree: An Index Structure for High-Dimensional Data”. International Conference on Very Large Data Bases (VLDB’96). pp. 28-39. 1996.

[BKO+99] M. de Berg, M. van Kreveld, M. Overmars y O. Schwarzkopf: “Computational Geometry: Algorithms and Applications”. Springer. 1999.

Referencias

247

[BKS+90] N. Beckmann, H.P. Kriegel, R. Schneider y B. Seeger; “The R*-tree: An Efficient and Robust Access Method for Points and Rectangles”. ACM SIGMOD Conference (SIGMOD’90). pp. 322-331. 1990.

[BKS93a] T. Brinkhoff, H.P. Kriegel y B. Seeger; “Efficient Processing of Spatial Joins Using R-Trees”. ACM SIGMOD Conference (SIGMOD’93). pp. 237-246. 1993.

[BKS93b] T. Brinkhoff, H.P. Kriegel y R. Schneider; “Comparison of Approximations of Complex Objects Used for Approximation-based Query Processing in Spatial Database Systems”, International Conference on Data Engineering (ICDE'93). pp. 40-49. 1993.

[BKS+94] T. Brinkhoff, H.P. Kriegel, R. Schneider y B. Seeger; “Multi-Step Processing of Spatial Joins”. ACM SIGMOD Conference (SIGMOD’94). pp. 197-208. 1994.

[BrB97] G. Brassard y P. Bratley; “Fundamentos de Algoritmia”. Prentice Hall Inc. 1997.

[BrK94a] T. Brinkhoff y H.P. Kriegel, “The Impact of Global Clustering on Spatial Database Systems”. International Conference on Very Large Data Bases (VLDB’94). pp. 168-179. 1994.

[BrK94b] T. Brinkhoff y H.P. Kriegel; “Approximations for a Multi-Step Processing of Spatial Joins”. International Workshop on Advanced Research in Geographic Information Systems, Lecture Notes in Computer Science (Springer), Vol. 884. pp. 25-34. 1994.

[Bro90] A.J. Broder; “Strategies for Efficient Incremental Nearest Neighbor Search”. Pattern Recognition, Vol. 23, Nº 1-2. pp. 171-178. 1990.

[Bro01] P. Brown; “Object-Relational Database Development: A Plumber’s Guide”. Prentice Hall PTR. 2001.

[CaK97] M. J. Carey y D. Kossmann; “On Saying “Enough Already!” in SQL”. ACM SIGMOD Conference (SIGMOD’97). pp. 219-230. 1997.

[ChD85] H.T. Chou y D.J. DeWitt; “An Evaluation of Buffer Management Strategies for Relational Database Systems”. International Conference on Very Large Data Bases (VLDB’85). pp. 127-141. 1985.

[ChF98] K.L. Cheung y A.W. Fu; “Enhanced Nearest Neighbour Search on the R-tree”. ACM SIGMOD Record, Vol. 27, Nº 3. pp.16-21. 1998.

[ChN97] E.P. Chan y J.N. Ng; “A General and Efficient Implementation of Geometric Operators and Predicates”. Advances in Spatial Databases (SSD’97), Lecture Notes in Computer Science (Springer), Vol. 1262. pp. 69-93. 1997.

[ChW83] F.Y. Chin y C.A. Wang; “Optimal Algorithms for the Intersection and the Minimum Distance Problems Between Planar Polygons”. IEEE Transactions on Computers, Vol. 32, Nº 12. pp.1203-1207. 1983.

Referencias

248

[ChW84] F.Y. Chin y C.A. Wang; “Minimum Vertex Distance Between Separable Convex Polygons”. Information Processing Letters, Vol. 18, Nº 1. pp.41-45. 1984.

[Cla94] K.L. Clarkson; “An Algorithm for Approximate Closest-Point Queries”. Symposium on Computational Geometry. pp. 160-164. 1994.

[CLR90] T.H. Cormen, C.E. Leiserson y R.L. Rivest; “Introduction to Algorithms”. Mc-Graw-Hill Companies Inc. 1990.

[CMT+00a] A. Corral, Y. Manolopoulos, Y. Theodoridis y M. Vassilakopoulos; “Closest Pair Queries in Spatial Databases”, ACM SIGMOD Conference (SIGMOD’00), pp. 189-200. 2000.

[CMT+00b] A. Corral, Y. Manolopoulos, Y. Theodoridis y M. Vassilakopoulos; “Algorithms for Processing Closest Pair Queries in Spatial Databases”, Technical Report, Department of Informatics, Aristotle University of Thessaloniki, November 2000.

[Com79] D. Comer; “The Ubiquitous B-tree”. ACM Computing Surveys, Vol. 11, Nº 2. pp. 121-137. 1979.

[CoS00] A. Corral y J. Samos; “Evaluación de Políticas de Reemplazo de Páginas para Consultas de los Pares más Cercanos utilizando R-trees”. V Jornadas de Ingeniería del Software y Bases de Datos. pp. 397-408. 2000.

[CRV01] A. Corral, J. Rodriguez y M. Vassilakopoulos; “Distance-Based Queries in Multidimensional Data Spaces using R-trees”. Aceptado en 8th Panhellenic Conference on Informatics (PCI’01), en prensa. 2001.

[CVM99] A. Corral, M. Vassilakopoulos y Y. Manolopoulos; “Algorithms for Joining R-Trees and Linear Region Quadtrees”. Advances in Spatial Databases (SSD’99), Lecture Notes in Computer Science (Springer), Vol. 1651. pp. 251-269. 1999.

[CVM01] A. Corral, M. Vassilakopoulos y Y. Manolopoulos; “The Impact of Buffering for the Closest Pairs Queries using R-trees”. Advances in Databases and Information Systems (ADBIS’01), Lecture Notes in Computer Science (Springer), Vol. 2151. pp. 41-54. 2001.

[DeP99] A. De Miguel y M. Piattini; “Fundamentos y Modelos de Bases de Datos”. RA-MA Editorial. 1999.

[DKL+94] D.J. DeWitt, N. Kabra, J. Luo, J. M. Patel y J. B. Yu; “Client-Server Paradise”. International Conference on Very Large Data Bases (VLDB’94). pp. 558-569. 1994.

[Ede85] H. Edelsbrunner; “Computing the Extreme Distances Between Two Convex Polygons”. Journal of Algorithms, Vol. 6, Nº 2. pp.213-224. 1985.

[EfH84] W. Effelsberg y T. Harder; “Principles of Database Buffer Management”. ACM Transactions on Database Systems, Vol. 9, Nº 4. pp. 560-595. 1984.

Referencias

249

[ElN97] R. Elmasri y S.B. Navathe; “Sistemas de Bases de Datos: Conceptos Fundamentales”. Addison-Wesley Iberoaméricana. 1997.

[FBF77] J.H. Friedman, J.L. Bentley y R.A. Finkel; “An Algorithm for Finding Best Matches in Logarithmic Expected Time”. ACM Transactions on Mathematical Software, Vol. 3, Nº 3. pp. 209-226. 1977.

[FiB74] R.A. Finkel y J.L. Bentley; “Quadtrees: A Data Structure for Retrieval on Composite Keys”. Acta Informatica, Vol. 4, Nº 1. pp. 1-9. 1974.

[Fre87] M. Freeston; “The BANG File: A New Kind of Grid File”. ACM SIGMOD Conference (SIGMOD’87). pp. 260-269. 1987.

[Fre95] M. Freeston; “A General Solution of the n-dimensional B-tree Problem”. ACM SIGMOD Conference (SIGMOD’95). pp. 80-91. 1995.

[FSS+86] M.L. Fredman, R. Sedgewick, D.D. Sleator y R.E. Tarjan; “The Pairing Heap: A New Form of Self-Adjusting Heap”. Algorithmica, Vol. 1, Nº 1. pp. 111-129. 1986.

[GaG98] V. Gaede y O. Guenther; “Multidimensional Access Methods”. ACM Computer Surveys, Vol. 30, Nº 2. pp. 170-231. 1998.

[Gar82] I. Gargantini; “An Effective Way to Represent Quadtrees”. Communications of ACM, Vol. 25, Nº 12. pp. 905-910. 1982.

[GJK88] E.G. Gilbert, D.W. Johnson y S.S. Keerthi; “A Fast Procedure for Computing the Distance Between Complex Objects in Three-dimensional Space”. IEEE Journal of Robotics and Automation, Vol. 4, Nº 2. pp.193-203. 1988.

[GRS95] R.H. Güting, T. Ridder y M. Schneider; “Implementation of the ROSE Algebra: Efficient Algorithms for Realm-Based Spatial Data Types”. Advances in Spatial Databases (SSD’95), Lecture Notes in Computer Science (Springer), Vol. 951. pp. 216-239. 1995.

[Gün93] O. Günther; “Efficient Computation of Spatial Joins”. International Conference on Data Engineering (ICDE’93). pp. 50-59. 1993.

[Gün89] O. Günther; “The Design of the Cell Tree: An Object-Oriented Index Structure for Geometric Databases”. International Conference on Data Engineering (ICDE’89). pp. 598-605. 1989.

[GüS93] R.H. Güting y M. Schneider; “Realms: A Foundation for Spatial Data Types in Database Systems”. Advances in Spatial Databases (SSD’93), Lecture Notes in Computer Science (Springer), Vol. 692. pp. 14-35. 1993.

[Gut84] A. Guttman; “R-trees: A Dynamic Index Structure for Spatial Searching”. ACM SIGMOD Conference (SIGMOD’84). pp. 47-57. 1984.

Referencias

250

[Güt89] R.H. Güting; “Gral: An Extensible Relational System for Geometric Applications”. International Conference on Very Large Data Bases (VLDB’89). pp. 33-44. 1989.

[Güt94] R.H. Güting; “An Introduction to Spatial Database Systems”. VLDB Journal, Vol. 3, Nº 4. pp. 357-399. 1994.

[GUW99] H. Garcia-Molina, J. Ullman y J. Widom; “Database System Implementation”. Prentice may. 1999.

[HAK00] A. Hinneburg, C.C. Aggarwal y D.A. Keim; “What is the Nearest Neighbor in High Dimensional Spaces?”. International Conference on Very Large Data Bases (VLDB’00). pp. 506-515. 2000.

[Hin85] K. Hinrichs; “Implementation of the Grid File: Design Concepts and Experience”. BIT, Vol. 25, Nº 4. pp. 569-592. 1985.

[HJR97a] Y.W. Huang, N. Jing y E.A. Rundensteiner; “Spatial Joins Using R-trees: Breadth-First Traversal with Global Optimizations”. International Conference on Very Large Data Bases (VLDB’97). pp. 396-405. 1997.

[HJR97b] Y.W. Huang, N. Jing y E.A. Rundensteiner; “A Cost Model for Estimating the Performance of Spatial Joins Using R-trees”. International Conference on Scientific and Statistical Database Management (SSDBM’97). pp. 30-38. 1997.

[HjS95] G.R. Hjaltason y H. Samet; “Ranking in Spatial Databases”. Advances in Spatial Databases (SSD’95), Lecture Notes in Computer Science (Springer), Vol. 951. pp. 83-95. 1995.

[HjS98] G.R. Hjaltason y H. Samet; “Incremental Distance Join Algorithms for Spatial Databases”. ACM SIGMOD Conference (SIGMOD’98). pp. 237-248. 1998.

[HjS99] G.R. Hjaltason y H. Samet; “Distance Browsing in Spatial Databases”. ACM Transactions on Database Systems (TODS), Vol. 24, Nº 2. pp. 265-318. 1999.

[HoS78] E. Horowitz y S. Sahni; “Fundamentals of Computer Algorithms”. Computer Science Press. 1978.

[HoS91] E.G. Hoel y H. Samet; “Efficient Processing of Spatial Queries in Line Segment Databases”. Advances in Spatial Databases (SSD’91), Lecture Notes in Computer Science (Springer), Vol. 525. pp. 237-256. 1991.

[HoS95] E.G. Hoel y H. Samet; “Benchmarking Spatial Join Operations with Spatial Output”. International Conference on Very Large Data Bases (VLDB’95). pp. 606-618. 1995

[HSW88] A. Hutflesz, H.W. Six y P. Widmayer; “Twin Grid Files: Space Optimizing Access Schemes”. ACM SIGMOD Conference (SIGMOD’88). pp. 183-190. 1988.

Referencias

251

[HSW89] A. Henrich, H.W. Six y P. Widmayer; “The LSD-Tree: Spatial Access to Multidimensional Point and Nonpoint Objects”. International Conference on Very Large Data Bases (VLDB’89). pp. 45-53. 1989.

[Iba76] T. Ibaraki; “Theoretical Comparisons of Search Strategies in Branch-and-Bound Algorithms”. InternationaL Journal of Computer and Information Sciences, Vol. 5, Nº 4. pp. 315-344. 1976.

[Iba87] T. Ibaraki; “Annals of Operations Research”. J.C. Batlzer AG, Scientific Publishing Company. 1987.

[Jag90] H.V. Jagadish; “Spatial Search with Polyhedra”. International Conference on Data Engineering (ICDE’90). pp. 311-319. 1990.

[JoS94] T. Johnson y D. Shasha; “2Q: A Low Overhead High Performance Buffer Management Replacement Algorithm”. International Conference on Very Large Data Bases (VLDB’94). pp. 439-450. 1994.

[KaF93] I. Kamel y C. Faloutsos, “On Packing R-trees”. International Conference on Information and Knowledge Management (CIKM’93). pp. 490-499. 1993.

[KaF94] I. Kamel y C. Faloutsos; “Hilbert R-tree: An Improved R-tree using Fractals”. International Conference on Very Large Data Bases (VLDB’94). pp. 500-509. 1994.

[KaS97] N. Katayama y S. Satoh; “The SR-tree: An Index Structure for High-Dimensional Nearest Neighbor Queries”. ACM SIGMOD Conference (SIGMOD’97). pp. 369-380. 1997.

[Knu86] D.E. Knuth; “El Arte de Programar Ordenadores: Ordenación y Búsqueda”. Ediciones Reverté. 1986.

[KoS97] N. Koudas y K.C. Sevcik; “Size Separation Spatial Join”. ACM SIGMOD Conference (SIGMOD’97). pp. 324-335. 1997.

[KoS98] N. Koudas y K.C. Sevcik; “High Dimensional Similarity Joins: Algorithms y Performance Evaluation”. International Conference on Data Engineering (ICDE’98). pp. 466-475. 1998.

[LaT96] R. Laurini y D. Thompson; “Fundamental on Spatial Information Systems”. Academic Press, 1996.

[LEL97] S.T. Leutenegger, J.M. Edgington y M.A. Lopez; “STR: A Simple and Efficient Algorithm for R-Tree Packing”. International Conference on Data Engineering (ICDE’97). pp. 497-506. 1997.

[LeL98] S.T. Leutenegger y M.A. Lopez; “The Effect of Buffering on the Performance of R-Trees”. International Conference on Data Engineering (ICDE’98). pp. 164-171. 1998.

Referencias

252

[LiC91] M.C. Lin y J.F. Canny; “A Fast Algorithm for Incremental Distance Calculation”. IEEE International Conference on Robotics and Automation. pp.1008-1014. 1991.

[LJF94] K.I. Lin, H.V. Jagadish y C. Faloutsos; “The TV-Tree: An Index Structure for High-Dimensional Data”. VLDB Journal, Vol. 3, Nº 4. pp. 517-542. 1994.

[LoR94] M.L. Lo y C.V. Ravishankar; “Spatial Joins Using Seeded Trees”. ACM SIGMOD Conference (SIGMOD’94). pp. 209-220. 1994.

[LoR95] M.L. Lo y C.V. Ravishankar; “Generating Seeded Trees from Data Sets”. Advances in Spatial Databases (SSD’99), Lecture Notes in Computer Science (Springer), Vol. 951. pp. 328-347. 1995.

[LoR96] M.L. Lo y C.V. Ravishankar; “Spatial Hash-Joins”. ACM SIGMOD Conference (SIGMOD’96). pp. 247-258. 1996.

[LoR98] M.L. Lo y C.V. Ravishankar; “The Design and Implementation of Seeded Trees: An Efficient Method for Spatial Joins”. IEEE Transactions on Knowledge and Data Engineering (TKDE), Vol. 10, Nº 1. pp. 136-152. 1998.

[LoS90] D.B. Lomet y B. Salzberg; “The hB-Tree: A Multiattribute Indexing Method with Good Guaranteed Performance”. ACM Transactions on Database Systems (TODS), Vol. 15, Nº 4. pp. 625-658. 1990.

[MaP98] N. Mamoulis y D. Papadias; “Constraint-Based Algorithms for Computing Clique Intersection Joins”. ACM Advances in Geographic Information Systems (ACM-GIS’98). pp. 118-123. 1998.

[MaP99] N. Mamoulis y D. Papadias; “Integration of Spatial Join Algorithms for Processing Multiple Inputs”. ACM SIGMOD Conference (SIGMOD’99). pp. 1-12. 1999.

[MaP00] N. Mamoulis y D. Papadias; “Multiway Spatial Joins”. Technical Report, Descargable: http://www.cs.ust.hk/faculty/dimitris/PAPERS/hkust-cs00-01.pdf. January 2000.

[MeN95] K. Mehlhorn y S. Näher; “LEDA: A Platform for Combinatorial and Geometric Computing”. Communications of the ACM (CACM), Vol. 38, Nº 1. pp. 96-102. 1995.

[MTT99] Y. Manolopoulos, Y. Theodoridis y V. Tsotras; “Advanced Database Indexing”. Kluwer Academic Publishers. 1999.

[MuS86] O.J. Murphy y S.M. Selkow; “The Efficiency of Using k-d-trees for Finding Nearest Neighbor in Discrete Space”. Information Processing Letters, Vol. 23, Nº 4. pp. 215-218. 1986.

Referencias

253

[NHS84] J. Nievergelt, H. Hinterberger y K.C. Sevcik; “The Grid File: An Adaptable, Symmetric Multikey File Structure”. ACM Transactions on Database Systems (TODS), Vol. 9, Nº 1. pp. 38-71. 1984.

[OhS83] Y. Ohsawa y M. Sakauchi; “The BD-Tree - A New N-Dimensional Data Structure with Highly Efficient Dynamic Characteristics”. IFIP World Computer Congress (IFIP’83). pp. 539-544. 1983.

[One94] P. O’neil; “Database. Principles, Programming and Performance”. Morgan-Kaufman Publishers Inc. 1994.

[OOW93] E.J. O'Neil, P.E. O'Neil y G. Weikum; “The LRU-K Page Replacement Algorithm For Database Disk Buffering”. ACM SIGMOD Conference (SIGMOD’93). pp. 297-306. 1993.

[Ora01] Oracle Technology Network; “Oracle Spatial User’s Guide and Reference”. Descargable: http://technet.oracle.com/doc/Oracle8i_816/inter.816/a77132.pdf. 2001.

[Ore86] J. A. Orenstein; “Spatial Query Processing in an Object-Oriented Database System”. ACM SIGMOD Conference (SIGMOD’86). pp. 326-336. 1986.

[OrM88] J. A. Orenstein y F.A. Manola; “PROBE Spatial Data Modeling and Query Processing in an Image Database Application”. IEEE Transactions on Software Engineering, Vol. 14, Nº 5. pp. 611-629. 1988.

[Oro98] J. O’rourke; “Computational Geometry in C”. Cambridge University Press. 1998.

[PaD96] J. M. Patel y D. J. DeWitt; “Partition Based Spatial-Merge Join”. ACM SIGMOD Conference (SIGMOD’96). pp. 259-270. 1996.

[PaM96] A. Papadopoulos y Y. Manolopoulos; “Global Page Replacement in Spatial Databases”. Database and Expert Systems Applications (DEXA’96), Lecture Notes in Computer Science (Springer), Vol. 1134. pp.855-864. 1996.

[PaM97] A. Papadopoulos y Y. Manolopoulos; “Performance of Nearest Neighbor Queries in R-Trees”. International Conference on Database Theory (ICDT’97), Lecture Notes in Computer Science (Springer), Vol. 1186. pp. 394-408. 1997.

[PaM98] A. Papadopoulos y Y. Manolopoulos; “Similarity Query Processing Using Disk Arrays”. ACM SIGMOD Conference (SIGMOD’98). pp. 225-236. 1998.

[Par97] Paradise Team; “Building a Scaleable Geo-Spatial DBMS: Technology, Implementation, and Evaluation”. ACM SIGMOD Conference (SIGMOD’97). pp. 336-347. 1997.

[PCC99] H.H. Park, G.H. Cha y C.W. Chung; “Multi-way Spatial Joins Using R-Trees: Methodology and Performance Evaluation”. Advances in Spatial Databases (SSD'99), Lecture Notes in Computer Science, Vol. 1651. pp. 229-250. 1999.

Referencias

254

[PMT99] D. Papadias, N. Mamoulis y Y. Theodoridis; “Processing and Optimization of Multiway Spatial Joins Using R-Trees”. ACM SIGACT-SIGMOD-SIGART Symposium on Principles of Database Systems (PODS’99). pp. 44-55. 1999.

[Pol96] A. Polo; “Índices Multiatributo m-Q para Máquinas de Bases de Datos Masivamente Paralelas”. Tesis Doctoral, Universidad Politécnica de Madrid (España). 1996.

[PrS85] F.P. Preparata y M.I. Shamos; “Computational Geometry: An Introduction”. Springer. 1985.

[PrS88] F.P. Preparata y M.I. Shamos; “Computational Geometry: An Introduction”. Springer-Verlag New York Inc. 1988.

[PRS99] A. Papadopoulos, P. Rigaux y M. Scholl; “A Performance Evaluation of Spatial Join Processing Strategies”. Advances in Spatial Databases (SSD’99), Lecture Notes in Computer Science (Springer), Vol. 1651. pp. 286-307. 1999.

[Ram97] R. Ramakrishnan; “Database Management Systems”. McGraw-Hill Companies Inc. 1997.

[RKV95] N. Roussopoulos, S. Kelley y F. Vincent; “Nearest Neighbor Queries”. ACM SIGMOD Conference (SIGMOD’95). pp 71-79. 1995.

[Rob81] J.T. Robinson; “The K-D-B-Tree: A Search Structure For Large Multidimensional Dynamic Indexes”. ACM SIGMOD Conference (SIGMOD’81). pp. 10-18. 1981.

[RoL85] N. Roussopoulos y D. Leifker; “Direct Spatial Search on Pictorial Databases Using Packed R-Trees”. ACM SIGMOD Conference (SIGMOD’85). pp. 17-31. 1985.

[Rot91] D. Rotem; “Spatial Join Indices”. International Conference on Data Engineering (ICDE’91). pp. 500-509. 1991.

[RRP96] K.G. Ramakrishnan, M.G. Resende y P.M. Pardalos; “A Branch and Bound Algorithm for the Quadratic Assignment Problem using a Lower Bound Based on Linear Programming”. State of the Art in Global Optimization: Computational Methods and Application. Kluwer Academic Publishers. pp. 57-73. 1996.

[RSV01] P. Rigaux, M. Scholl y A. Voisard; “Spatial Databases with Application to GIS”. Morgan-Kaufmann Publishers Inc. 2001.

[SaA95] H. Samet y W.G. Aref; “Spatial Data Models and Query Processing”. Modern Database Systems: The Object Model, Interoperability and Beyond. Ed. Addison-Wesley/ACM Press. pp. 338-360. 1995.

[Sam90a] H. Samet; “The Design and Analysis of Spatial Data Structures”. Addison-Wesley. 1990.

Referencias

255

[Sam90b] H. Samet; “Applications of Spatial Data Structures: Computer Graphics, Image Processing, and GIS”. Addison-Wesley. 1990.

[SaS82] G.M. Sacco y M. Schkolnick; “A Mechanism for Managing the Buffer Pool in a Relational Database System Using the Hot Set Model”. International Conference on Very Large Data Bases (VLDB’82). pp. 257-262. 1982.

[Sch97] M. Schneider; “Spatial Data Types for DataBase Systems. Finite Resolution Geometry for Geographic Information Systems”. Lecture Notes in Computer Science (Springer), Vol. 1288. 1997.

[ScS92] C. Schwarz y M. Smid; “An O(n log n log log n) Algorithm for the On-Line Closest Pair Problem”. ACM/SIGACT-SIAM Symposium on Discrete Algorithms (SODA’92). pp. 280-285. 1992.

[ScV92] M. Scholl y A. Voisard; “ObjectOriented Database Systems for Geographic Applications: An Example with O2”. Geographic Database Management Systems. pp. 103-137. 1992.

[ScW86] H. Schek y W. Waterfeld; “A Database Kernel System for Geoscientific Applications”. International Symposium on Spatial Data Handling. pp. 273-288. 1986.

[Seg95] R. Sedgewick, “Algoritmos en C++”. Addison-Wesley/Díaz de Santos. 1995.

[Seg98] R. Sedgewick, “Algorithms in C”. Addison-Wesley. 1998.

[SeK90] B. Seeger y H.P. Kriegel; “The Buddy-Tree: An Efficient and Robust Access Method for Spatial Data Base Systems”. International Conference on Very Large Data Bases (VLDB’90). pp. 590-601. 1990.

[SeP97] P. Seshadri y M. Paskin; “PREDATOR: An OR-DBMS with Enhanced Data Types”. ACM SIGMOD Conference (SIGMOD’97). pp. 568-571. 1997.

[SFG+93] M. Stonebraker, J. Frew, K. Gardels y J. Meredith: “The Sequoia 2000 Benchmark”. ACM SIGMOD Conference (SIGMOD’93). pp. 211, 1993.

[ShA97] J.C. Shafer y R. Agrawal; “Parallel Algorithms for High-dimensional Similarity Joins for Data Mining Applications”. International Conference on Very Large Data Bases (VLDB’97). pp. 176-185. 1997.

[ShH75] M.I. Shamos y D. Hoey; “Closest-Point Problems”. IEEE Symposium on Foundations of Computer Science. pp. 151-162, 1975.

[SKS98] A. Silberschatz, H.F. Korth y S. Sudarshan; “Fundamentos de Bases de Datos, 3ª Edición”. McGraw-Hill/Interamericana de España. 1998.

[SML00] H. Shin, B. Moon y S. Lee, “Adaptive Multi-Stage Distance Join Processing”. ACM SIGMOD Conference (SIGMOD’00). pp. 343-354. 2000.

Referencias

256

[SPJ99] M. Salas, A. Polo y E. Jurado; “Una Revisión de los Métodos de Acceso Multidimensionales”. Novática (Bases de Datos Avanzadas), Nº 140. pp. 40-47. 1999.

[Spr91] R.F. Sproull; “Refinements to Nearest-Neighbor Searching in k-dimensional Trees”. Algorithmica, Vol. 6, Nº 4. pp. 579-589. 1991.

[SRF87] T. Sellis, N. Roussopoulos y C. Faloutsos, “R+-tree: A Dynamic Index for Multi-Dimensional Objects”. International Conference on Very Large Data Bases (VLDB’87). pp. 507-518. 1987.

[SSS92] C. Schwarz, M. Smid y J. Snoeyink; “An Optimal Algorithm for the On-Line Closest-Pair Problem”. Symposium on Computational Geometry. pp. 330-336. 1992.

[StM97] M. Stonebreaker y D. Moore; “Objetc Relational DBMSs: The Next Great Wave”. Morgan-Kaufmann Publishers Inc. 1997.

[SYU+00] Y. Sakurai, M. Yoshikawa, S. Uemura y H. Kojima; “The A-tree: An Index Structure for High-Dimensional Spaces Using Relative Approximation”. International Conference on Very Large Data Bases (VLDB’00). pp. 516-526. 2000.

[Tam82] M. Tamminen; “The Extendible Cell Method for Closest Point Problem”. BIT, Vol. 22, Nº 1. pp. 27-41. 1982.

[TSS98] Y. Theodoridis, E. Stefanakis y T. Sellis; “Cost Models for Join Queries in Spatial Databases”. International Conference on Data Engineering (ICDE´98). pp. 476-483. 1998.

[TSS00] Y. Theodoridis, E. Stefanakis y T. Sellis; “Efficient Cost Models for Spatial Queries Using R-Trees”. IEEE Transactions on Knowledge and Data Engineering (TKDE 2000), Vol. 12, Nº 1. pp. 19-32. 2000.

[Val87] P. Valduriez; “Join Indices”. ACM Transactions on Database Systems (TODS), Vol. 12, Nº 2. pp. 218-246. 1987.

[ViO92] T. Vijlbrief y P. van Oosterom; “The GEO ++ System: An Extensible GIS”. International Symposium on Spatial Data Handling, Vol. 1. pp. 40-50. 1992.

[WaH87] T.C. Waugh y R.G. Healey; “The GEOVIEW Design: A Relational Data Base Approach to Geographical Data Handling”. International Journal of Geographical Information Systems, Vol. 1, Nº 2. pp. 101-118. 1987.

[WhJ96] D.A. White y R. Jain; “Similarity Indexing with the SS-tree”. International Conference on Data Engineering (ICDE’96). pp. 516-523. 1996.

[YuM98] C.T. Yu y W. Meng; “Principles of Database Query Processing for Advanced Applications”. Morgan-Kaufmann Publishers Inc. 1998.

Referencias

257

[ZCF+97] C. Zaniolo, S. Ceri, C. Faloutsos, R.T. Snodgrass, V.S. Subrahmanian y R. Zicari; “Advanced Database Systems”. Morgan-Kaufmann Publishers Inc. 1997.

259

APÉNDICE A

Como hemos visto en el capítulo 2 de esta tesis, en [HjS98] se presentan tres variantes (Basic, Evenly y Simultaneous) de un algoritmo incremental e iterativo para resolver el Join Basado en Distancias. Dicho algoritmo es iterativo puesto que utiliza una cola de prioridad (implementada como un montículo) 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 (característica de los algoritmos no incrementales).

Las tres variantes del algoritmo que se presentan en [HjS98] se clasifican en función de la política con que recorren los R*-trees (RP y RQ). Si la prioridad se le da arbitrariamente a uno de los dos R*-trees (por ejemplo, a RP) 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 R*-trees, surge la alternativa Simultaneous.

A continuación detallamos en seudo código las tres alternativas incrementales implementadas [HjS98] para compararlas con nuestros algoritmos branch-and-bound no-incrementales, suponiendo que todas las estructuras de datos están creadas y bien definidas.

Algoritmo para el Join Basado en Distancias Incremental e Iterativo [HjS98], versión Basic.

JoinDistanciaBasic(RaizP, RaizQ: R_nodo; K: Entero) 1 M = crearMonticulo(); 2 PQ = crearColaPrioridad(m_RaizP, m_RaizQ); 3 Dmax = ∞; 4 M.insertar(0, direccion_RaizP, nivel_RaizP, mbr_RaizP, direccion_RaizQ, nivel_RaizQ, mbr_RaizQ); 5 PQ.insertarar(0, nivel_RaizP, mbr_RaizP, nivel_RaizQ, mbr_RaizQ, K, Dmax); 6 Pares_Cercanos_Devueltos = 0; 7 k = K; 8 while ((not(M.estaVacio())) and (Pares_Cercanos_Devueltos < K)) do 9 Elem = M.eliminarMinimo(); 10 PQ.eliminar(Elem.mbr1, Elem.mbr2) 11 if ((Elem.nivel_ItemP = 0) and (Elem.nivel_ItemQ = 0)) then // (punto/punto) 12 return Elem; 13 Pares_Cercanos_Devueltos = Pares_Cercanos_Devueltos + 1;

Apéndice A

260

14 k = k – 1; 15 else 16 if (Elem.nivel_ItemP ≠ 0) then // (mbr/*) 17 ItemP = LeerNodo(Elem.direccion_ItemP); 18 ItemQ = Elem.ItemQ; 19 if (Elem.nivel_ItemP – 1 = 0) then // (punto/*) 20 for every punto en ItemP do 21 if (Elem.nivel_ItemQ == 0) then // (punto/punto) 22 MINMINDIST = Distancia_Punto_Punto(mbr_ItemP, mbr_ItemQ); 23 MAXMAXDIST = Distancia_Punto_Punto(mbr_ItemP, mbr_ItemQ); 24 else // (punto/mbr) 25 MINMINDIST = Distancia_Punto_MBR(mbr_ItemP, mbr_ItemQ); 26 MAXMAXDIST = Distancia_Punto_MBR(mbr_ItemP, mbr_ItemQ); 27 endif 28 if (MINMINDIST <= Dmax) then 29 M.insertar(MINMINDIST, direccion_ItemP, nivel_ItemP, mbr_ItemP, direccion_ItemQ, nivel_ItemQ, mbr_ItemQ); 30 PQ.insertar(MAXMAXDIST, nivel_ItemP, mbr_ItemP, nivel_ItemQ, mbr_ItemQ, k, Dmax); 31 endfi 32 enddo 33 else // (mbr/*) 34 for every mbr en ItemP do 35 if (Elem.nivel_ItemQ = 0) then // (mbr/punto) 36 MINMINDIST = Distancia_MBR_Punto(mbr_ItemP, mbr_ItemQ); 37 MAXMAXDIST = Distancia_MBR_Punto(mbr_ItemP, mbr_ItemQ); 38 else // (mbr/mbr) 39 MINMINDIST = Distancia_MBR_MBR(mbr_ItemP, mbr_ItemQ); 40 MAXMAXDIST = Distancia_MBR_MBR(mbr_ItemP, mbr_ItemQ); 41 endif 42 if (MINMINDIST <= Dmax) then 43 M.insertar(MINMINDIST, direccion_ItemP, nivel_ItemP, mbr_ItemP, direccion_ItemQ, nivel_ItemQ, mbr_ItemQ); 44 PQ.insertar(MAXMAXDIST, nivel_ItemP, mbr_ItemP, nivel_ItemQ, mbr_ItemQ, k, Dmax); 45 endif 46 enddo 47 endif 48 else // (punto/*) 49 ItemP = Elem.ItemP; 50 ItemQ = LeerNodo(Elem.direccion_ItemQ); 51 if (Elem.nivel_ItemQ – 1 = 0) then // (punto/punto) 52 for every punto en ItemQ do 53 MINMINDIST = Distancia_Punto_Punto(mbr_ItemP, mbr_ItemQ); 54 MAXMAXDIST = Distancia_Punto_Punto(mbr_ItemP, mbr_ItemQ); 55 if (MINMINDIST <= Dmax) then 56 M.insertar(MINMINDIST, direccion_ItemP, nivel_ItemP, mbr_ItemP, direccion_ItemQ, nivel_ItemQ, mbr_ItemQ); 57 PQ.insertar(MAXMAXDIST, nivel_ItemP, mbr_ItemP, nivel_ItemQ, mbr_ItemQ, k, Dmax); 58 endif 59 enddo 60 else // (punto/mbr) 61 for every mbr en ItemQ do 62 MINMINDIST = Distancia_Punto_MBR(mbr_ItemP, mbr_ItemQ); 63 MAXMAXDIST = Distancia_Punto_MBR(mbr_ItemP, mbr_ItemQ); 64 if (MINMINDIST <= Dmax) then 65 M.insertar(MINMINDIST, direccion_ItemP, nivel_ItemP, mbr_ItemP,

Apéndice A

261

direccion_ItemQ, nivel_ItemQ, mbr_ItemQ); 66 PQ.insertar(MAXMAXDIST, nivel_ItemP, mbr_ItemP, nivel_ItemQ, mbr_ItemQ, k, Dmax); 67 endif 68 enddo 69 endif 70 endif 71 endif 72 enddo 73 M.destruirMonticulo(); 74 PQ.destruirColaPrioridad();

Algoritmo para el Join Basado en Distancias Incremental e Iterativo [HjS98], versión Evenly.

JoinDistanciaEvenly(RaizP, RaizQ: R_nodo; K: Entero) 1 M = crearMonticulo(); 2 PQ = crearColaPrioridad(m_RaizP, m_RaizQ); 3 Dmax = ∞; 4 M.insertar(0, direccion_RaizP, nivel_RaizP, mbr_RaizP, direccion_RaizQ, nivel_RaizQ, mbr_RaizQ); 5 PQ.insertar(0, nivel_RaizP, mbr_RaizP, nivel_RaizQ, mbr_RaizQ, K, Dmax); 6 Pares_Cercanos_Devueltos = 0; 7 k = K; 8 while ((not(M.estaVacio())) and (Pares_Cercanos_Devueltos < K)) do 9 Elem = M.eliminarMinimo(); 10 PQ.eliminar(Elem.mbr1, Elem.mbr2) 11 if ((Elem.nivel_ItemP = 0) and (Elem.nivel_ItemQ = 0)) then // (punto/punto) 12 return Elem; 13 Pares_Cercanos_Devueltos = Pares_Cercanos_Devueltos + 1; 14 k = k – 1; 15 else 16 if ((Elem.nivel_ItemP = 0) and (Elem.nivel_ItemQ ≠ 0)) then // (punto/*) 17 ItemP = Elem.ItemP; 18 ItemQ = LeerNodo(Elem.direccion_ItemQ); 19 if (Elem.nivel_ItemQ – 1 = 0) then // (punto/punto) 20 for every punto en ItemQ do 21 MINMINDIST = Distancia_Punto_Punto(mbr_ItemP, mbr_ItemQ); 22 MAXMAXDIST = Distancia_Punto_Punto(mbr_ItemP, mbr_ItemQ); 23 if (MINMINDIST <= Dmax) then 24 M.insertar(MINMINDIST, direccion_ItemP, nivel_ItemP, mbr_ItemP, direccion_ItemQ, nivel_ItemQ, mbr_ItemQ); 25 PQ.insertar(MAXMAXDIST, nivel_ItemP, mbr_ItemP, nivel_ItemQ, mbr_ItemQ, k, Dmax); 26 endif 27 enddo 28 else // (punto/mbr) 29 for every mbr en ItemQ do 30 MINMINDIST = Distancia_Punto_MBR(mbr_ItemP, mbr_ItemQ); 31 MAXMAXDIST = Distancia_Punto_MBR(mbr_ItemP, mbr_ItemQ); 32 if (MINMINDIST <= Dmax) then 33 M.insertar(MINMINDIST, direccion_ItemP, nivel_ItemP, mbr_ItemP, direccion_ItemQ, nivel_ItemQ, mbr_ItemQ); 34 PQ.insertar(MAXMAXDIST, nivel_ItemP, mbr_ItemP, nivel_ItemQ, mbr_ItemQ, k, Dmax); 35 endif 36 enddo

Apéndice A

262

37 endif 38 endif 39 if ((Elem.nivel_ItemP ≠ 0) and (Elem.nivel_ItemQ = 0)) then // (*/punto) 40 ItemP = LeerNodo(Elem.direccion_ItemP); 41 ItemQ = Elem.ItemQ; 42 if (Elem.nivel_ItemP – 1 = 0) then // (punto/punto) 43 for every punto en ItemP do 44 MINMINDIST = Distancia_Punto_Punto(mbr_ItemP, mbr_ItemQ); 45 MAXMAXDIST = Distancia_Punto_Punto(mbr_ItemP, mbr_ItemQ); 46 if (MINMINDIST <= Dmax) then 47 M.insertar(MINMINDIST, direccion_ItemP, nivel_ItemP, mbr_ItemP, direccion_ItemQ, nivel_ItemQ, mbr_ItemQ); 48 PQ.insertar(MAXMAXDIST, nivel_ItemP, mbr_ItemP, nivel_ItemQ, mbr_ItemQ, k, Dmax); 49 endif 50 enddo 51 else // (mbr/punto) 52 for every mbr en ItemP do 53 MINMINDIST = Distancia_MBR_Punto(mbr_ItemP, mbr_ItemQ); 54 MAXMAXDIST = Distancia_MBR_Punto(mbr_ItemP, mbr_ItemQ); 55 if (MINMINDIST <= Dmax) then 56 M.insertar(MINMINDIST, direccion_ItemP, nivel_ItemP, mbr_ItemP, direccion_ItemQ, nivel_ItemQ, mbr_ItemQ); 57 PQ.insertar(MAXMAXDIST, nivel_ItemP, mbr_ItemP, nivel_ItemQ, mbr_ItemQ, k, Dmax); 58 endif 59 enddo 60 endif 61 endif 62 if ((Elem.nivel_ItemP ≠ 0) and (Elem.nivel_ItemQ ≠ 0)) then // (*/*) 63 if (Elem.nivel_ItemP > Elem.nivel_ItemQ) then 64 PROCESARNODO_RP; 65 else 66 if (Elem.nivel_ItemP < Elem.nivel_ItemQ) then 67 PROCESARNODO_RQ; 68 else 69 if (Area(Elem.mbr_ItemP) ≥ Area(Elem.mbr_ItemQ)) then 70 PROCESARNODO_RP; 71 else 72 PROCESARNODO_RQ; 73 endif 74 endif 75 endfi 76 endif 77 enddo 78 M.destruirMonticulo(); 79 PQ.destruirColaPrioridad(); PROCESARNODO_RP; 1 ItemP = LeerNodo(Elem.direccion_ItemP); 2 ItemQ = ElemItemQ; 3 if (Elem.nivel_ItemP – 1 = 0) then // (punto/mbr) 4 for every punto en ItemP do 5 MINMINDIST = Distancia_Punto_MBR(mbr_ItemP, mbr_ItemQ); 6 MAXMAXDIST = Distancia_Punto_MBR(mbr_ItemP, mbr_ItemQ); 7 if (MINMINDIST <= Dmax) then 8 M.insertar(MINMINDIST, direccion_ItemP, nivel_ItemP, mbr_ItemP, direccion_ItemQ, nivel_ItemQ, mbr_ItemQ);

Apéndice A

263

9 PQ.insertar(MAXMAXDIST, nivel_ItemP, mbr_ItemP, nivel_ItemQ, mbr_ItemQ, k, Dmax); 10 endif 11 enddo 12 else // (mbr/mbr) 13 for every mbr en ItemP do 14 MINMINDIST = Distancia_MBR_MBR(mbr_ItemP, mbr_ItemQ); 15 MAXMAXDIST = Distancia_MBR_MBR(mbr_ItemP, mbr_ItemQ); 16 if (MINMINDIST <= Dmax) then 17 M.insertar(MINMINDIST, direccion_ItemP, nivel_ItemP, mbr_ItemP, direccion_ItemQ, nivel_ItemQ, mbr_ItemQ); 18 PQ.insertar(MAXMAXDIST, nivel_ItemP, mbr_ItemP, nivel_ItemQ, mbr_ItemQ, k, Dmax); 19 endif 20 enddo 21 endif PROCESARNODO_RQ; 1 ItemP = Elem.ItemP; 2 ItemQ = LeerNodo(Elem.direccion_ItemQ); 3 if (Elem.nivel_ItemQ – 1 = 0) then // (mbr/punto) 4 for every punto en ItemQ do 5 MINMINDIST = Distancia_MBR_Punto(mbr_ItemP, mbr_ItemQ); 6 MAXMAXDIST = Distancia_MBR_Punto(mbr_ItemP, mbr_ItemQ); 7 if (MINMINDIST <= Dmax) then 8 M.insertar(MINMINDIST, direccion_ItemP, nivel_ItemP, mbr_ItemP, direccion_ItemQ, nivel_ItemQ, mbr_ItemQ); 9 PQ.insertar(MAXMAXDIST, nivel_ItemP, mbr_ItemP, nivel_ItemQ, mbr_ItemQ, k, Dmax); 10 endif 11 enddo 12 else // (mbr/mbr) 13 for every mbr en ItemQ do 14 MINMINDIST = Distancia_MBR_MBR(mbr_ItemP, mbr_ItemQ); 15 MAXMAXDIST = Distancia_MBR_MBR(mbr_ItemP, mbr_ItemQ); 16 if (MINMINDIST <= Dmax) then 17 M.insertar(MINMINDIST, direccion_ItemP, nivel_ItemP, mbr_ItemP, direccion_ItemQ, nivel_ItemQ, mbr_ItemQ); 18 PQ.insertar(MAXMAXDIST, nivel_ItemP, mbr_ItemP, nivel_ItemQ, mbr_ItemQ, k, Dmax); 19 endif 20 enddo 21 endif

Algoritmo para el Join Basado en Distancias Incremental e Iterativo [HjS98], versión Simultaneous .

JoinDistanciaSimultaneous(RaizP, RaizQ: R_nodo; K: Entero) 1 M = crearMonticulo(); 2 PQ = crearColaPrioridad(m_RaizP, m_RaizQ); 3 Dmax = ∞; 4 M.insertar(0, direccion_RaizP, nivel_RaizP, mbr_RaizP, direccion_RaizQ, nivel_RaizQ, mbr_RaizQ); 5 PQ.insertar(0, nivel_RaizP, mbr_RaizP, nivel_RaizQ, mbr_RaizQ, K, Dmax); 6 Pares_Cercanos_Devueltos = 0; 7 k = K; 8 while ((not(M.estaVacio())) and (Pares_Cercanos_Devueltos < K)) do 9 Elem = M.eliminarMinimo(); 10 PQ.eliminar(Elem.mbr1, Elem.mbr2) 11 if ((Elem.nivel_ItemP = 0) and (Elem.nivel_ItemQ = 0)) then // (punto/punto) 12 return Elem;

Apéndice A

264

13 Pares_Cercanos_Devueltos = Pares_Cercanos_Devueltos + 1; 14 k = k – 1; 15 else 16 if ((Elem.nivel_ItemP = 0) and (Elem.nivel_ItemQ ≠ 0)) then // (punto/*) 17 ItemP = Elem.ItemP; 18 ItemQ = LeerNodo(Elem.direccion_ItemQ); 19 if (Elem.nivel_ItemQ – 1 = 0) then // (punto/punto) 20 for every punto en ItemQ do 21 MINMINDIST = Distancia_Punto_Punto(mbr_ItemP, mbr_ItemQ); 22 MAXMAXDIST = Distancia_Punto_Punto(mbr_ItemP, mbr_ItemQ); 23 if (MINMINDIST <= Dmax) then 24 M.insertar(MINMINDIST, direccion_ItemP, nivel_ItemP, mbr_ItemP, direccion_ItemQ, nivel_ItemQ, mbr_ItemQ); 25 PQ.insertar(MAXMAXDIST, nivel_ItemP, mbr_ItemP, nivel_ItemQ, mbr_ItemQ, k, Dmax); 26 endif 27 enddo 28 else // (punto/mbr) 29 for every mbr en ItemQ do 30 MINMINDIST = Distancia_Punto_MBR(mbr_ItemP, mbr_ItemQ); 31 MAXMAXDIST = Distancia_Punto_MBR(mbr_ItemP, mbr_ItemQ); 32 if (MINMINDIST <= Dmax) then 33 M.insertar(MINMINDIST, direccion_ItemP, nivel_ItemP, mbr_ItemP, direccion_ItemQ, nivel_ItemQ, mbr_ItemQ); 34 PQ.insertar(MAXMAXDIST, nivel_ItemP, mbr_ItemP, nivel_ItemQ, mbr_ItemQ, k, Dmax); 35 endif 36 enddo 37 endif 38 endif 39 if ((Elem.nivel_ItemP ≠ 0) and (Elem.nivel_ItemQ = 0)) then // (*/punto) 40 ItemP = LeerNodo(Elem.direccion_ItemP); 41 ItemQ = Elem.ItemQ; 42 if (Elem.nivel_ItemP – 1 = 0) then // (punto/punto) 43 for every punto en ItemP do 44 MINMINDIST = Distancia_Punto_Punto(mbr_ItemP, mbr_ItemQ); 45 MAXMAXDIST = Distancia_Punto_Punto(mbr_ItemP, mbr_ItemQ); 46 if (MINMINDIST <= Dmax) then 47 M.insertar(MINMINDIST, direccion_ItemP, nivel_ItemP, mbr_ItemP, direccion_ItemQ, nivel_ItemQ, mbr_ItemQ); 48 PQ.insertar(MAXMAXDIST, nivel_ItemP, mbr_ItemP, nivel_ItemQ, mbr_ItemQ, k, Dmax); 49 endif 50 enddo 51 else // (mbr/punto) 52 for every mbr en ItemP do 53 MINMINDIST = Distancia_MBR_Punto(mbr_ItemP, mbr_ItemQ); 54 MAXMAXDIST = Distancia_MBR_Punto(mbr_ItemP, mbr_ItemQ); 55 if (MINMINDIST <= Dmax) then 56 M.insertar(MINMINDIST, direccion_ItemP, nivel_ItemP, mbr_ItemP, direccion_ItemQ, nivel_ItemQ, mbr_ItemQ); 57 PQ.insertar(MAXMAXDIST, nivel_ItemP, mbr_ItemP, nivel_ItemQ, mbr_ItemQ, k, Dmax); 58 endif 59 enddo 60 endif 61 endif 62 if ((Elem.nivel_ItemP ≠ 0) and (Elem.nivel_ItemQ ≠ 0)) then // (*/*)

Apéndice A

265

63 ItemP = LeerNodo(Elem.direccion_ItemP); 64 ItemQ = LeerNodo(Elem.direccion_ItemQ); 65 if ((Elem.nivel_ItemP – 1 = 0) and (Elem.nivel_ItemQ – 1 = 0)) then // (punto/punto) 66 for every punto en ItemP do 67 for every punto en ItemQ do 68 MINMINDIST = Distancia_Punto_Punto(mbr_ItemP, mbr_ItemQ); 69 MAXMAXDIST = Distancia_Punto_Punto(mbr_ItemP, mbr_ItemQ); 70 if (MINMINDIST <= Dmax) then 71 M.insertar(MINMINDIST, direccion_ItemP, nivel_ItemP, mbr_ItemP, direccion_ItemQ, nivel_ItemQ, mbr_ItemQ); 72 PQ.insertar(MAXMAXDIST, nivel_ItemP, mbr_ItemP, nivel_ItemQ, mbr_ItemQ, k, Dmax); 73 endif 74 enddo 75 enddo 76 endif 77 if ((Elem.nivel_ItemP – 1 = 0) and (Elem.nivel_ItemQ – 1 ≠ 0)) then // (punto/mbr) 78 for every punto en ItemP do 79 for every mbr en ItemQ do 80 MINMINDIST = Distancia_Punto_MBR(mbr_ItemP, mbr_ItemQ); 81 MAXMAXDIST = Distancia_Punto_MBR(mbr_ItemP, mbr_ItemQ); 82 if (MINMINDIST <= Dmax) then 83 M.insertar(MINMINDIST, direccion_ItemP, nivel_ItemP, mbr_ItemP, direccion_ItemQ, nivel_ItemQ, mbr_ItemQ); 84 PQ.insertar(MAXMAXDIST, nivel_ItemP, mbr_ItemP, nivel_ItemQ, mbr_ItemQ, k, Dmax); 85 endif 86 enddo 87 enddo 88 endif 89 if ((Elem.nivel_ItemP – 1 ≠ 0) and (Elem.nivel_ItemQ – 1 = 0)) then // (mbr/punto) 90 for every mbr en ItemP do 91 for every punto en ItemQ do 92 MINMINDIST = Distancia_MBR_Punto(mbr_ItemP, mbr_ItemQ); 93 MAXMAXDIST = Distancia_MBR_Punto(mbr_ItemP, mbr_ItemQ); 94 if (MINMINDIST <= Dmax) then 95 M.insertar(MINMINDIST, direccion_ItemP, nivel_ItemP, mbr_ItemP, direccion_ItemQ, nivel_ItemQ, mbr_ItemQ); 96 PQ.insertar(MAXMAXDIST, nivel_ItemP, mbr_ItemP, nivel_ItemQ, mbr_ItemQ, k, Dmax); 97 endif 98 enddo 99 enddo 100 endif 101 if ((Elem.nivel_ItemP – 1 ≠ 0) and (Elem.nivel_ItemQ – 1 ≠ 0)) then // (mbr/mbr) 102 for every mbr en ItemP do 103 for every mbr en ItemQ do 104 MINMINDIST = Distancia_MBR_MBR(mbr_ItemP, mbr_ItemQ); 105 MAXMAXDIST = Distancia_MBR_MBR(mbr_ItemP, mbr_ItemQ); 106 if (MINMINDIST <= Dmax) then 107 M.insertar(MINMINDIST, direccion_ItemP, nivel_ItemP, mbr_ItemP, direccion_ItemQ, nivel_ItemQ, mbr_ItemQ); 108 PQ.insertar(MAXMAXDIST, nivel_ItemP, mbr_ItemP, nivel_ItemQ, mbr_ItemQ, k, Dmax); 109 endif 110 enddo 111 enddo 112 endif

Apéndice A

266

113 endfi 114 endif 115enddo 116M.destruirMonticulo(); 117PQ.destruirColaPrioridad();

“In my end is my beginning”

Thomas Stearn Eliot

Algoritmos para el Procesamiento de Consultas …acorral/acorralTesis.pdfUNIVERSIDAD DE ALMERÍA...

Documents

Transcript of Algoritmos para el Procesamiento de Consultas …acorral/acorralTesis.pdfUNIVERSIDAD DE ALMERÍA...