Micha Streppel TU Eindhoven  NCIM-Groep, the Netherlands and Ke Yi AT&T Labs, USA  HKUST, Hong Kong

A set S of N points in R d Build a data structure such that given a query range Q, S ∩ Q can be returned efficiently Q focus on range reporting, range aggregation in paper

size: M size: infinite block size: BI/O

1D: B-tree Size: O(N/B), Query: O(log B (N/B)+k/B)) 2D: Half planes [Agarwal et al. 2000] Size: O(N/B), Query: O(log B (N/B)+k/B)) Orthogonal rectangles [Arge et al. 1999] Size: O(N/B), Query: Θ((N/B) ε +k/B) Query: O(log B (N/B)+k/B)), Size: Θ((N/B) log(N/B)/loglog B N) kdB-tree [Robinson 1981] Size O(N/B), Query: O((N/B) ½ + k/B) Q Q Q Exact range searching is difficult!

Internal memory: BBD-tree [Arya and Mount, 1995] BAR-tree [Duncan et al. 2001] Size: O(N), Query: O(log(N) + 1/ε + k ε ) for any convex Q External memory: this paper! Q radius = ε · diam(Q)

Internal memoryExternal memory 1D O(log(N) + k)O(log B (N/B) + k/B) 2D: half planes O(log(N) + k)O(log B (N/B) + k/B) 2D: orthogonal rectangles O(N ε + k)O((N/B) ε + k/B) 2D: kd-trees O(N ½ + k)O((N/B) ½ + k/B) 2D: approximate range searching O(log(N) + 1/ε + k ε )O(log B (N/B) + 1/ε + k ε /B) Query bounds of linear structures in internal/external memory previously

B = 3 Internal memory: O(N ½ + k) External memory: O((N/B) ½ + k/B) for orthogonal rectangle ranges

A space-partitioning scheme Similar to kd-tree But also use diagonal cuts All cells are convex and fat Some cuts have to be unbalanced But no two consecutive unbalanced cuts Height: O(log N) Query range intersects O(log(N) + 1/ε + k ε ) cells (any convex range)

Top-down blocking Rules for u: Check u’s two subtrees T1, T2 Add u if both have ≥ B/2 nodes If T1 small, check if entire T1 fits then add T1 else do not add u Not possible for both T1 and T2 to be small B = 8

Any subtree T u is stored in O(|T u |/B+ 1 ) blocks

Q QεQε nodes completely inside Q ε nodes intersects both Q and ∂Q ε total #: O(1/ε) total I/O: O(1/ε) total #: O(k ε ) organized in O(1/ε) subtrees total I/O: O(1/ε + k ε /B)

There are O(log N) such nodes, but we would like O(log B N) I/Os

size = B/ 2 − 1

Identify shallow nodes top-down u is shallow if there is a path of length log(B) beneath u is stored in more than c blocks For such a u Do a BFS for log(B) levels Move these nodes from their original blocks to a new block size = B/ 2 − 1 Achieving the desired query I/O: O(log B (N/B) + 1/ε + k ε /B)

Construction: O(N/B · log M/B (N/B)) I/Os Same as sorting Insertions and deletions Use partial rebuilding O(log B N + 1/B · log M/B (N/B)log(N/B)) I/Os amortized

S: a collection of objects The density of S is the smallest number λ such that any ball b is intersected by at most λ objects o in S with radius(o) ≥ radius(b) [de Berg et al. 1997] low density high density

The object-BAR-tree (using guarding sets [de Berg et al. 2003] ) Size: O(λN/B) Query: O(log B (N/B) + λ/B· 1 /ε + λ·k ε /B) Construction: O(λ N/B · log M/B (N/B)) low density high density

Extends to d dimensions Query becomes O(log B (N/B) + 1/ε d-1 + k ε /B) Non-convex query ranges Query becomes O(log B (N/B) + 1/ε d + k ε /B) Construction and query process does not depend on ε The actual cost is O(log B (N/B) + min ε {1/ε d-1 + k ε /B}) Open problems How to update the object-BAR-tree efficiently?

Thank you!