- Related Questions & Answers
- Kernel Data Structures
- Correspondence Based Data Structures
- Data objects and Structures
- Abstract Data Type in Data Structures
- Inbuilt Data Structures in C#
- Inbuilt Data Structures in Python
- Data Structures Stack Primitive Operations
- Tail Recursion in Data Structures
- Bernoulli Distribution in Data Structures
- Binomial Distribution in Data Structures
- Geometric Distribution in Data Structures
- Stack ADT in Data Structures
- Adjacency lists in Data Structures
- What are JavaScript data types and data structures?
- In-built Data Structures in Python

- Selected Reading
- UPSC IAS Exams Notes
- Developer's Best Practices
- Questions and Answers
- Effective Resume Writing
- HR Interview Questions
- Computer Glossary
- Who is Who

A kinetic data structure is defined as a data structure implemented to track an attribute of a geometric system that is moving continuously. For example, a kinetic convex hull data structure tracks the convex hull of a group of n moving points.

The development of kinetic data structures was inspired by computational geometry problems involving physical objects in continuous motion, for example collision or visibility detection in robotics, animation or computer graphics.

Kinetic data structures are implemented on systems where there is a set of values that are changing as a function of time, in a called fashion. So the system has some values, and for each system value v, it is denoting that v=f(t). Kinetic data structures permit queries on a system at the current virtual time t, and two additional operations

- advance(t): The system to time t is advanced.
- change(v,f(t)): The trajectory of value v to f(t), as of the current time, is altered.

Additional operations can be supported. For example, kinetic data structures are frequently implemented with a set of points. In this case, the structure typically permits points to be inserted and deleted.

A kinetic data structure permits the values stored in it to change continuously with time. In principle, this can be approximated by sampling the position of the points at fixed intervals of time, and deleting and re-inserting each point into a "static" (traditional) data structure. However, such an approach is susceptible to oversampling or undersampling, depending on what interval of time is implemented, and can also be wasteful of computational resources.

The following general approach can be implemented to build kinetic data structures

- A data structure on the system at the current time t is stored. This data structure permits queries on the system at the current virtual time.
- The data structure with certificates is augmented. Certificates are treated as conditions under which the data structure is accurate. The certificates are all true now, and the data structure will only cease to be perfect or accurate when one of the certificates is no longer true.
- The failure time of each certificate is computed, the time when it will cease to be true.
- The certificates in a priority queue is stored, keyed by their failure times.
- To advance to time t, look at the certificate with the minimum failure time from the priority queue. If the certificate fails prior to time t, delete or pop it from the queue and fix the data structure so it is perfect or accurate at the time of failure, and update the certificates. Repeat this until and unless the certificate with the lowest failure time in the priority queue fails after time t. If the certificate with the minimum failure time in the priority queue fails after time t, then all certificates are declared as true at time t so the data structure can correctly answer queries at time t.

Certificate failures are denoted to as "events". An event is declared as internal if the property maintained by the kinetic data structure does not change at the time of occurrence of event. An event is declared as external if the property maintained by the data structure changes at the time of occurrence of event.

When implementing the certificates approach, there are four measures of performance. We call a quantity is small if it is a polylogarithmic function of n, or is O(n€) for randomly small €, where n is treated as the number of objects.

Advertisements