Results 1  10
of
18
Optimal dynamic vertical ray shooting in rectilinear planar subdivisions
"... Optimal dynamic vertical ray shooting in rectilinear planar subdivisions. In this paper we consider the dynamic vertical ray shooting problem, that is the task of maintaining a dynamic set S of n non intersecting horizontal line segments in the plane subject to a query that reports the first segment ..."
Abstract

Cited by 14 (0 self)
 Add to MetaCart
Optimal dynamic vertical ray shooting in rectilinear planar subdivisions. In this paper we consider the dynamic vertical ray shooting problem, that is the task of maintaining a dynamic set S of n non intersecting horizontal line segments in the plane subject to a query that reports the first segment in S intersecting a vertical ray from a query point. We develop a linearsize structure that supports queries, insertions and deletions in O(log n) worstcase time. Our structure works in the comparison model and uses a RAM.
SpaceEfficient Dynamic Orthogonal Point Location, Segment Intersection, and Range Reporting
, 2008
"... We describe an asymptotically optimal datastructure for dynamic point location for horizontal segments. For n linesegments, queries take O(log n) time, updates take O(log n) amortized time and the data structure uses O(n) space. This is the first structure for the problem that is optimal in space ..."
Abstract

Cited by 13 (2 self)
 Add to MetaCart
We describe an asymptotically optimal datastructure for dynamic point location for horizontal segments. For n linesegments, queries take O(log n) time, updates take O(log n) amortized time and the data structure uses O(n) space. This is the first structure for the problem that is optimal in space and time (modulo the possibility of removing amortization). We also describe dynamic data structures for orthogonal range reporting and orthogonal intersection reporting. In both data structures for n points (segments) updates take O(log n) amortized time, queries take O(log n+k log n / log log n) time, and the structures use O(n) space, where k is the size of the output. The model of computation is the unit cost RAM.
Implementing Partial Persistence in ObjectOriented Languages
, 2008
"... A partially persistent data structure is a data structure which preserves previous versions of itself when it is modified. General theoretical schemes are known (e.g. the fat node method) for making any data structure partially persistent. To our knowledge however no general implementation of these ..."
Abstract

Cited by 3 (0 self)
 Add to MetaCart
A partially persistent data structure is a data structure which preserves previous versions of itself when it is modified. General theoretical schemes are known (e.g. the fat node method) for making any data structure partially persistent. To our knowledge however no general implementation of these theoretical methods exists to date. This paper evaluates different methods to achieve this goal and presents the first working implementation of partial persistence in the objectoriented language Java. Our approach is transparent, i.e., it allows any existing data structures to become persistent without changing its implementation where all previous solutions require an extensive modification of the code by hand. This transparent property is important in view of the large number of algorithmic results that rely on persistence. Our implementation uses aspectoriented programming, a modularization technique which allows us to instrument the existing code with the needed hooks for the persistence implementation. The implementation is then validated by running benchmarks to analyze both the cost of persistence and of the aspect oriented approach. We also illustrate its applicability by implementing a random binary search tree and making it persistent, and then using the resulting structure to implement a point location data structure in just a few lines.
Nonoblivious retroactive data structures
, 2007
"... The idea of a retroactive version of a data structure is to maintain a timeordered sequence of operations while allowing the user to revise the operation sequence by invoking and revoking (i.e., inserting and deleting, respectively) operations anywhere in the sequence—including backwards in time. I ..."
Abstract

Cited by 1 (1 self)
 Add to MetaCart
(Show Context)
The idea of a retroactive version of a data structure is to maintain a timeordered sequence of operations while allowing the user to revise the operation sequence by invoking and revoking (i.e., inserting and deleting, respectively) operations anywhere in the sequence—including backwards in time. In many applications of retroactivity, operations depend on the outcomes of previous queries, and therefore the data structures need to identify the queries whose outcome changes when a revision is performed retroactively. Existing notions of retroactivity, however, do not keep track of queries in the operation sequence. Therefore, they cannot efficiently identify the queries that become inconsistent as a result of a retroactive revision. In this paper, we propose and study a new model of retroactivity, called nonoblivious retroactivity, where both updates and queries are maintained as part of the operation sequence. In this model, a revision to the operation sequence returns the earliest operation that becomes inconsistent, i.e., an operation whose return value differs from before. This mechanism enables the user to efficiently locate the affected operation and decide to perform further revisions as necessary to reestablish the consistency of the operation sequence. We investigate several nonoblivious data structures and prove some lower bounds in the proposed model. 1 1
6.851: Advanced Data Structures Spring 2007
, 2007
"... The topic of this lecture is the fusion tree, another data structure to solve the predecessor/successor problem. Given a static set S ⊆ {0, 1, 2,..., 2 w − 1}, fusion trees can answer predecessor/successor queries in O(log w n). Essentially, fusion trees are Btrees with a branching factor of k = Θ( ..."
Abstract
 Add to MetaCart
(Show Context)
The topic of this lecture is the fusion tree, another data structure to solve the predecessor/successor problem. Given a static set S ⊆ {0, 1, 2,..., 2 w − 1}, fusion trees can answer predecessor/successor queries in O(log w n). Essentially, fusion trees are Btrees with a branching factor of k = Θ(w1/5). Tree height is
DYNAMIC DATA STRUCTURES FOR GEOMETRIC SEARCH AND RETRIEVAL
, 2013
"... Data structures for geometric search and retrieval are of significant interest in areas such as computational geometry, computer graphics, and computer vision. The focus of this dissertation is on the design of efficient dynamic data structures for use in approximate retrieval problems in multidimen ..."
Abstract
 Add to MetaCart
Data structures for geometric search and retrieval are of significant interest in areas such as computational geometry, computer graphics, and computer vision. The focus of this dissertation is on the design of efficient dynamic data structures for use in approximate retrieval problems in multidimensional Euclidean space. A number of data structures have been proposed for storing multidimensional point sets. We will focus on quadtreebased structures. Quadtreebased structures possess a number of desirable properties, and they have been shown to be useful in solving a wide variety of query problems, especially when approximation is involved. First, we introduce two dynamic quadtreebased data structures for storing a set of points in space, called the quadtreap and the splay quadtree. The quadtreap is a randomized variant of a quadtree that supports insertion and deletion and has logarithmic height with high probability. The splay quadtree is also a quadtree variant, but this data structure is selfadjusting, that is, it rebalances itself depending on the access pattern. It supports efficient insertion and deletion in the amortized sense. We also study how to dynamically maintain an important geometric structure,
Dynamic Quadtree Mesh Refinement ∗
, 2007
"... Many algorithms exist for producing quality meshes when the input point cloud is known a priori. However, modern finite element simulations and graphics applications need to change the input set during the simulation dynamically. We show how to dynamically update the mesh under changes in the input ..."
Abstract
 Add to MetaCart
(Show Context)
Many algorithms exist for producing quality meshes when the input point cloud is known a priori. However, modern finite element simulations and graphics applications need to change the input set during the simulation dynamically. We show how to dynamically update the mesh under changes in the input as points are added or removed one by one while maintaining quality guarantees with an optimal number of additional vertices. Our algorithm runs in optimal O(lg L/s) time per update, where L/s is the spread of the input. To obtain our result, we present a novel and simple quad and octtree parallel mesh generation algorithm, then apply selfadjusting computation techniques to dynamize the algorithm. 1
Active Data Structures and Applications to Dynamic and Kinetic Algorithms
, 2006
"... We propose and study a novel datastructuring paradigm, called active data structures. Like a time machine, active data structures allow changes to occur not only in the present but at any point in time—including the past. Unlike most time machines, where changes to the past are incorporated and pro ..."
Abstract
 Add to MetaCart
(Show Context)
We propose and study a novel datastructuring paradigm, called active data structures. Like a time machine, active data structures allow changes to occur not only in the present but at any point in time—including the past. Unlike most time machines, where changes to the past are incorporated and propagated automatically by magic, active data structures systematically communicate with the affected parties, prompting them to take appropriate actions. We demonstrate an efficient maintenance of three active data structures: (monotone) priority queue, dictionary, and compareandswap. These data structures, when paired with the selfadjusting computation framework, create new possibilities in kinetic and dynamic algorithms engineering. Based on this interaction, we present three practical algorithms: a new algorithm for 3d kinetic/dynamic convex hull, an algorithm for dynamic listsorting, and an algorithm for dynamic singlesource shortestpath (based on Dijkstra). Our 3d kinetic convex hull is the first efficient kinetic 3d convex hull algorithm that supports dynamic changes simultaneously. This thesis provides an implementation for selected active data structures and applications, whose performance is analyzed both theoretically and experimentally. 1
Programming languages for interactive computing
, 2007
"... Traditional programming languages are algorithmic: they are best suited to writing programs that acquire all their inputs before executing and only produce a result on termination. By contrast most applications are interactive: they maintain ongoing interactions with their environments. Modern syste ..."
Abstract
 Add to MetaCart
(Show Context)
Traditional programming languages are algorithmic: they are best suited to writing programs that acquire all their inputs before executing and only produce a result on termination. By contrast most applications are interactive: they maintain ongoing interactions with their environments. Modern systems address this incompatibility by manually extending the execution model of the host language to support interaction, usually by embedding an eventdriven state management scheme which executes fragments of imperative code in response to interactions, the job of each executed fragment being to restore the internal consistency of the computation. The downside of this approach to interaction is that it relies heavily on mutable stores and sideeffects and mixes application logic in with behaviour which is more properly the responsibility of an execution model. I describe a programming model called declarative interaction which supports interaction directly. The distinguishing feature of the model is its modal construal of state and interaction. 1 Declarative interaction Almost all software systems today are interactive, in that they maintain ongoing interactions with