Results 1  10
of
10
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 5 (3 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.
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 4 (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.
Abstract Implementing Partial Persistence in ObjectOriented Languages
"... 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 1 (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. 1
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
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
ON THE TRACEABILITY OF THE COMPOSITIONAL PROCESS
"... Composition is viewed as a process that has its own temporal dimension. This process can sometimes be highly nonlinear, sometimes is carried out in realtime during a performance. A model is proposed that unifies the creational and the performance time and that traces the history of the creation of ..."
Abstract
 Add to MetaCart
Composition is viewed as a process that has its own temporal dimension. This process can sometimes be highly nonlinear, sometimes is carried out in realtime during a performance. A model is proposed that unifies the creational and the performance time and that traces the history of the creation of a piece. This model is based on a transformation that enhances data structures to become persistent. Confluent persistence allows navigation to any previous version of a piece, to create version branches at any point, and to combine different versions with each other. This concept is tuned to integrate two important aspects, retroactivity and multiplicities. Three representative problems are posed: How to define dependancies on entities that change over time, how to introduce changes expost that affect future versions, and how to continue working on parallel versions of a piece. Solutions based on our test implementation in the Scala language are presented. Our approach opens new possibilities in the area of music analysis and can conflate disparate notions of composition such as tape composition, interactive sound installation, and live improvisation. They can be represented by the same data structure and both offline and realtime manipulations happen within the same transactional model.
unknown title
, 2012
"... In this first lecture we cover results on persistent data structures, which are data structures where we keep all information about past states. Persistent data structures are part of the larger class of temporal data structures. The other kind of temporal data structures, retroactive data structure ..."
Abstract
 Add to MetaCart
In this first lecture we cover results on persistent data structures, which are data structures where we keep all information about past states. Persistent data structures are part of the larger class of temporal data structures. The other kind of temporal data structures, retroactive data structures, are the topic of lecture 2. Usually we deal with data structure updates by mutating something in the existing data structure: either its data or the pointers that organize it. In the process we lose information previous data structures states. Persistent data structures do not lose any information. For several cases of data structures and definitions of persistence it is possible to transform a plain data structure into a persistent one with asymptotically minimal extra work or space overhead. A recurring theme in this area is that the model is crucial to the results. Partial and full persistence correspond to time travel with a branching universe model such as the one in Terminator, and Deja Vu parts 1 and 2 2 Model and definitions 2.1 The pointer machine model of data structures In this model we think of data structures as collections of nodes of a bounded size with entries for
unknown title
"... The main idea of persistent data structures is that when a change is made in the past, an entirely new universe is obtained. A more sciencefiction approach to time travel is that you can make a change in the past and see its results not only in the current state of the data structure, but also all ..."
Abstract
 Add to MetaCart
The main idea of persistent data structures is that when a change is made in the past, an entirely new universe is obtained. A more sciencefiction approach to time travel is that you can make a change in the past and see its results not only in the current state of the data structure, but also all the changes in between the past and now. We maintain one timeline of updates and queries for a persistent data structure: Usually, operations are appended at the end of the time line (present time). With retroactive data structures we can do that in the past too. 2 Retroactivity The following operations are supported by retroactive DS: • Insert(t, update) inserts operation “update ” at time t • Delete(t) deletes the operation at time t • Query(t, query) queries the DS with a “query ” at time t Uppercase Insert indicates an operation on retroactive DS, lowercase update is the operation on the actual DS. You can think of time t as integers, but a better approach is to use an ordermaintanance DS to avoid using nonintegers (in case you want to insert an operation between times t and t + 1), as mentioned in the first lecture. There are three types of retroactivity: • Partial Query always done at t = ∞ (now) 1 • Full Query at any time t (possibly in the past) • Nonoblivious Insert, Delete, Query at any time t, also if an operation modifies DS, we must say which future queries are changed. 2.1 Easy case with commutativity and inversions Assume the following hold: • Commutative updates: x.y = y.x (x followed by y is the same as y followed by x); that is the updates can be reordered ⇒ Insert(t, op) = Insert(now, op). • Invertible updates: There exists an operation x −1, such that x.x −1 = ∅ ⇒ Delete(t, op) = Insert(now, op −1) 2.1.1 Partial retroactivity These two assumptions allow us to solve some retroactive problems easily, such as: • hashing • array with operation A[i]+ = ∆ (but no direct assignment) 2.2 Full retroactivity First, lets define the search problem:
A Selfadjusting Data Structure for Multidimensional Point Sets ⋆
"... Abstract. A data structure is said to be selfadjusting if it dynamically reorganizes itself to adapt to the pattern of accesses. Efficiency is typically measured in terms of amortized complexity, that is, the average running time of an access over an arbitrary sequence of accesses. The best known e ..."
Abstract
 Add to MetaCart
Abstract. A data structure is said to be selfadjusting if it dynamically reorganizes itself to adapt to the pattern of accesses. Efficiency is typically measured in terms of amortized complexity, that is, the average running time of an access over an arbitrary sequence of accesses. The best known example of such a data structure is Sleator and Tarjan’s splay tree. In this paper, we introduce a selfadjusting data structure for storing multidimensional point data. The data structure is based on a quadtreelike subdivision of space. Like a quadtree, the data structure implicitly encodes a subdivision of space into cells of constant combinatorial complexity. Each cell is either a quadtree box or the settheoretic difference of two such boxes. Similar to the traditional splay tree, accesses are based on an splaying operation that restructures the tree in order to bring an arbitrary internal node to the root of the tree. We show that many of the properties enjoyed by traditional splay trees can be generalized to this multidimensional version.
ABSTRACT Title of dissertation: DYNAMIC DATA STRUCTURES FOR GEOMETRIC SEARCH AND RETRIEVAL
"... 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,