Self-adjusting computation uses a combination of dynamic dependence graphs and memoization to efficiently update the output of a program as the input changes incrementally or dynamically over time. Related work showed various theoretical results, indicating that the approach can be effective for a reasonably broad range of applications. In this article, we describe algorithms and implementation techniques to realize self-adjusting computation and present an experimental evaluation of the proposed approach on a variety of applications, ranging from simple list primitives to more sophisticated computational geometry algorithms. The results of the experiments show that the approach is effective in practice, often offering orders of magnitude speedup from recomputing the output from scratch. We believe this is the first experimental evidence that incremental computation of any type is effective in practice for a reasonably broad set of applications.

Abstract. Define a static algorithm as an algorithm that computes some combinatorial property of its input consisting of static, i.e., non-moving, objects. In this paper, we describe a technique for syntactically transforming static algorithms into kinetic algorithms, which compute properties of moving objects. The technique o«ers capabilities for composing kinetic algorithms, for integrating dynamic and kinetic changes, and for ensuring robustness even with fixed-precision floating-point arithmetic. To evaluate the e«ectiveness of the approach, we implement a library for performing the transformation, transform a number of algorithms, and give an experimental evaluation. The results show that the technique performs well in practice. 1

For many geometric problems, there are ecient algorithms that surprisingly use very little extra space other than the given array holding the input. For many geometric query problems, there are ecient data structures that need no extra space at all other than an array holding a permutation of the input. In this paper, we obtain the rst such space-economical solutions for a number of fundamental problems, including three-dimensional convex hulls, two-dimensional Delaunay triangulations, xed-dimensional range queries, and xed-dimensional nearest neighbor queries.

We present simple, fully dynamic and kinetic data structures, which are variants of a dynamic two-dimensional range tree, for maintaining the closest pair and all nearest neighbors for a set of n moving points in the plane; insertions and deletions of points are also allowed. If no insertions or deletions take place, the structure for the closest pair uses O(n log n) space, and processes O(n 2 βs+2(n) log n) critical events, each in O(log 2 n) time. Here s is the maximum number of times where the distances between any two specific pairs of points can become equal, βs(q) = λs(q)/q, and λs(q) is the maximum length of Davenport-Schinzel sequences of order s on q symbols. The dynamic version of the problem incurs a slight degradation in performance: If m ≥ n insertions and deletions are performed, the structure still uses O(n log n) space, and processes O(mnβs+2(n) log³ n) events, each in O(log³ n) time. Our kinetic data structure for all nearest neighbors uses O(n log² n) space, and processes O(n 2 β 2 s+2 (n) log3 n) critical events. The expected time to process all events is O(n 2 β 2 s+2 (n) log4 n), though processing a single event may take �(n) expected time in the worst case. If m ≥ n insertions and deletions are performed, then the expected number of events is O(mnβ 2 s+2 (n) log3 n) and processing them all takes O(mnβ 2 s+2 (n) log4 n). An insertion or deletion takes O(n) expected time.

We present a simple randomized scheme for triangulating a set P of n points in the plane, and construct a kinetic data structure which maintains the triangulation as the points of P move continuously along piecewise algebraic trajectories of constant description complexity. Our triangulation scheme experiences an expected number of O(n 2 βs+2(n) log 2 n) discrete changes, and handles them in a manner that satisfies all the standard requirements from a kinetic data structure: compactness, efficiency, locality and responsiveness. Here s is the maximum number of times where any specific triple of points of P can become collinear, βs+2(q) = λs+2(q)/q, and λs+2(q) is the maximum length of Davenport-Schinzel sequences of order s + 2 on n symbols. Thus, compared to the previous solution of Agarwal et al. [4], we achieve a (slightly) improved bound on the number of discrete changes in the triangulation. In addition, we believe that our scheme is simpler to implement and analyze. Categories and Subject Descriptors F.2.2 [Analysis of algorithms and problem complexity]: Nonnumerical algorithms and problems—Geometrical problems and computations; G.2.1 [Discrete mathematics]: Combinatorics—Combinatorial algorithms

Abstract. In self-adjusting computation, programs respond automatically and efficiently to modifications to their data by tracking the dynamic data dependences of the computation and incrementally updating the output as needed. In this tutorial, we describe the self-adjustingcomputation model and present the language ∆ML (Delta ML) for writing self-adjusting programs. 1

Abstract: We propose data structures for answering a geodesic-distance query between two query points in a two-dimensional or three-dimensional dynamic environment, in which obstacles are deforming continuously. Each obstacle in the environment is modeled as the convex hull of a continuously deforming point cloud. The key to our approach is to avoid maintaining the convex hull of each point cloud explicitly but still able to retain sufficient geometric information to estimate geodesic distances in the free space. 1

Abstract not found