Static Data Structures Research Articles

Competitive Data-Structure Dynamization

Data-structure dynamization is a general approach for making static data structures dynamic. It is used extensively in geometric settings and in the guise of so-called merge (or compaction) policies in big-data databases such as LevelDB and Google Bigtable. Previous theoretical work is based on worst-case analyses for uniform inputs—insertions of one item at a time and non-varying read rate. In practice, merge policies must not only handle batch insertions and varying read/write ratios, they can take advantage of such non-uniformity to reduce cost on a per-input basis. To model this, we initiate the study of data-structure dynamization through the lens of competitive analysis via two new online set-cover problems. For each, the input is a sequence of disjoint sets of weighted items. The sets are revealed one at a time. The algorithm must respond to each with a set cover that covers all items revealed so far. It obtains the cover incrementally from the previous cover by adding one or more sets and optionally removing existing sets. For each new set the algorithm incurs build cost equal to the weight of the items in the set. In the first problem the objective is to minimize total build cost plus total query cost , where the algorithm incurs a query cost at each time \(t\) equal to the current cover size. In the second problem, the objective is to minimize the build cost while keeping the query cost from exceeding \(k\) (a given parameter) at any time. We give deterministic online algorithms for both variants, with competitive ratios of \(\Theta(\log^{*}n)\) and \(k\) , respectively. The latter ratio is optimal for the second variant.

Static and Streaming Data Structures for Fréchet Distance Queries

Given a curve P with points in ℝ d in a streaming fashion, and parameters ɛ > 0 and k , we construct a distance oracle that uses \(O(\frac{1}{\varepsilon })^{kd}\log \varepsilon ^{-1}\) space, and given a query curve Q with k points in ℝ d returns in \(\tilde{O}(kd)\) time a 1+ɛ approximation of the discrete Fréchet distance between Q and P . In addition, we construct simplifications in the streaming model, oracle for distance queries to a sub-curve (in the static setting), and introduce the zoom-in problem. Our algorithms work in any dimension d , and therefore we generalize some useful tools and algorithms for curves under the discrete Fréchet distance to work efficiently in high dimensions.

DIRECTGO : A New DIRECT -Type MATLAB Toolbox for Derivative-Free Global Optimization

In this work, we introduce DIRECTGO , a new MATLAB toolbox for derivative-free global optimization. DIRECTGO collects various deterministic derivative-free DIRECT -type algorithms for box-constrained, generally constrained, and problems with hidden constraints. Each sequential algorithm is implemented in two ways: using static and dynamic data structures for more efficient information storage and organization. Furthermore, parallel schemes are applied to some promising algorithms within DIRECTGO . The toolbox is equipped with a graphical user interface (GUI), ensuring the user-friendly use of all functionalities available in DIRECTGO . Available features are demonstrated in detailed computational studies using a comprehensive DIRECTGOLib v1.0 library of global optimization test problems. Additionally, 11 classical engineering design problems illustrate the potential of DIRECTGO to solve challenging real-world problems. Finally, the appendix gives examples of accompanying MATLAB programs and provides a synopsis of its use on the test problems with box and general constraints.

GPU based approach for fast generation of robot capability representations

Capability maps are an important tool for enabling robots to understand their bodies by providing a way of representing the dexterity of their arms. They are usually treated as static data structures be- cause of how computationally intensive they are to generate. We present a method for generating capability maps taking advantage of the parallelization that modern GPUs offer such that these maps are generated approximately 50 times faster than previous implementations. This system could be used in situations were the robot has to generate this maps fast, for example when using unknown tools.

I/O-efficient 2-d orthogonal range skyline and attrition priority queues

We present the first static and dynamic external memory data structures for variants of 2-d orthogonal range skyline reporting with worst-case logarithmic query and update I/O-complexity. The results are obtained by using persistent data structures and by extending the attrition priorities queues of Sundar (1989) [26] to also support real-time concatenation, a result of independent interest. We show that the problem is as hard as standard 2-d orthogonal range reporting in the indexability model by a lower bound on the I/O-complexity of 2-d orthogonal anti-dominance skyline reporting queries.

Streaming statistical models via Merge & Reduce

Merge & Reduce is a general algorithmic scheme in the theory of data structures. Its main purpose is to transform static data structures—that support only queries—into dynamic data structures—that allow insertions of new elements—with as little overhead as possible. This can be used to turn classic offline algorithms for summarizing and analyzing data into streaming algorithms. We transfer these ideas to the setting of statistical data analysis in streaming environments. Our approach is conceptually different from previous settings where Merge & Reduce has been employed. Instead of summarizing the data, we combine the Merge & Reduce framework directly with statistical models. This enables performing computationally demanding data analysis tasks on massive data sets. The computations are divided into small tractable batches whose size is independent of the total number of observations n. The results are combined in a structured way at the cost of a bounded O(log n) factor in their memory requirements. It is only necessary, though nontrivial, to choose an appropriate statistical model and design merge and reduce operations on a casewise basis for the specific type of model. We illustrate our Merge & Reduce schemes on simulated and real-world data employing (Bayesian) linear regression models, Gaussian mixture models and generalized linear models.

Optimal Solutions to the Sort Algorithms of Database Structure

Sorting is much used in massive data applications, insurance systems, education, health, business, etc. To the sorting operation that sorts the data as desired, quick access to the required data is achieved. Typically sorted data are organized in strings as file elements or tables. The most common case is when the tabular data is processed in the main memory of the computer. The paper presents the algorithms currently used for sorting objects that are involved in static and dynamic data structures. Then the selection of the data set on which particular algorithms will be applied will be made and the advantages and disadvantages of each of the algorithms in question will be seen.Thereafter, it is determined the efficiency of the sorting algorithm work and it is considered what is determinative when selecting the appropriate algorithm for sorting.

Didactic potential of using systems for visualization of algorithms in the process of teaching programming

The article is devoted to the didactic potential on the use of the visualizer of algorithms as software, which graphically demonstrates the work of algorithms for processing input data. There are described the difficulties arising during the study of the fundamentals of algorithmization and programming. The author proposed to use the algorithm visualizer, as an auxiliary visual means of teaching algorithmization, for more successful mastering the mechanism of the algorithms at lectures. The article discusses the functional requirements for the visualizer of algorithms, describes its main elements and guidelines for the use of visualizers of algorithms in the educational process. In order to increase the effectiveness of the educational process, it is proposed to use the visualizer of algorithms for teaching algorithms and programming for students of the “Applied Informatics” direction as future specialists in the information technologies.The purpose of the study is to increase the efficiency of the development of algorithmic thinking among students of the specialty “Computer Science”, due to the support and active use of the algorithm visualizer as an additional visual tool for learning when studying the course “Fundamentals of Programming”.Materials and research methods include the analysis of scientific and methodological literature on the subject under study, the analysis of the problem of developing algorithmic thinking by students, the practical implementation of the learning process of the basics of algorithmization and programming using the developed algorithms visualizer, the analysis of students’ survey results.Results. The research conducted by the author allowed the creation of an instrumental environment an algorithm visualizer that supports the formation of problem solving skills, enhancing the effectiveness of the learning process in the fundamentals of algorithmization and programming and the development of algorithmic thinking. Have been implemented visualizers, that allowing online demonstration of the work of algorithms for processing static data structures (arrays), which contributes to the comprehension and consolidation of theoretical material. Visualizers are introduced into the educational process at Balti State University A. Russo and are used in studying the course “Fundamentals of Programming”.Conclusion. The author comes to the conclusions about the expediency of the visual description of the algorithm, proposes methods for using the algorithms visualizer in the educational process, and highlights positive factors that affect the understanding the mechanism of algorithm execution when organizing training using visualizers.

All-pairs shortest paths in geometric intersection graphs

$\newcommand{\OO}[1]{O\left(#1\right)}$We present a simple and general algorithm for the all-pairs shortest paths (APSP) problem in unweighted geometric intersection graphs. Specifically we reduce the problem to the design of static data structures for offline intersection detection. Consequently we can solve APSP in unweighted intersection graphs of $n$ arbitrary disks in $\OO{n^2 \log n}$ time, axis-aligned line segments in $\OO{n^2 \log{\log n}}$ time, arbitrary line segments in $\OO{n^{7/3} \log^{1/3} n}$ time, $d$-dimensional axis-aligned unit hypercubes in $\OO{n^2 \log\log n}$ time for $d=3$ and $\OO{n^2 \log^{d-3} n}$ time for $d\geq4$, and $d$-dimensional axis-aligned boxes in $\OO{n^2 \log^{d-1.5} n}$ time for $d\geq2$. We also reduce the single-source shortest paths (SSSP) problem in unweighted geometric intersection graphs to decremental intersection detection. Thus, we obtain an $\OO{n \log n}$-time SSSP algorithm in unweighted intersection graphs of $n$ axis-aligned line segments.

Randomized Approximate Nearest Neighbor Search with Limited Adaptivity

We study the complexity of parallel data structures for approximate nearest neighbor search in d -dimensional Hamming space {0,1} d . A classic model for static data structures is the cell-probe model [27]. We consider a cell-probe model with limited adaptivity , where given a k ≥1, a query is resolved by making at most k rounds of parallel memory accesses to the data structure. We give two randomized algorithms that solve the approximate nearest neighbor search using k rounds of parallel memory accesses: —a simple algorithm with O ( k (log d ) 1/ k ) total number of memory accesses for all k ≥1; —an algorithm with O ( k +(1/ k log d ) O (1/ k ) ) total number of memory accesses for all sufficiently large k . Both algorithms use data structures of polynomial size. We prove an Ω(1/ k (log d ) 1/ k ) lower bound for the total number of memory accesses for any randomized algorithm solving the approximate nearest neighbor search within k ≤log log d /2log log log d rounds of parallel memory accesses on any data structures of polynomial size. This lower bound shows that our first algorithm is asymptotically optimal when k = O (1). And our second algorithm achieves the asymptotically optimal tradeoff between number of rounds and total number of memory accesses. In the extremal case, when k = O (log log d /log log log d ) is big enough, our second algorithm matches the Θ(log log d /log log log d ) tight bound for fully adaptive algorithms for approximate nearest neighbor search in [11].

Optimal Deterministic Shallow Cuttings for 3-d Dominance Ranges

Shallow cuttings are one of the most fundamental tools in range searching as many problems in the field admit efficient static data structures due to their application. We present the first efficient deterministic algorithms that, given n three-dimensional points, construct optimal-size (single and multiple) shallow cuttings for orthogonal dominance ranges. Specifically, we show how to construct a single shallow cutting in $$O\left( n\log n\right) $$ worst-case time, using $$O\left( n\right) $$ space. We also show that the same complexity suffices to construct simultaneously a logarithmic number of shallow cuttings on the input pointset. Our algorithms are optimal in the comparison and algebraic-comparison models, and constitute an important step forwards as the first improvement over previous deterministic polynomial-time guarantees by Matousek (Comput Geom 2(3):169–186, 1992) and Agarwal et al. (SIAM J Comput 29(3):912–953, 2000) matching the complexity of the optimal deteministic algorithm for the more general 3-d halfspace ranges by Chan and Tsakalidis (Discrete Comput Geom 56(4):866–881, 2016). Our methods yield worst-case efficient preprocessing algorithms for a series of important orthogonal range searching problems in the pointer machine and the word-RAM models, where such shallow cuttings are utilized to support queries efficiently.

A novel hardware support for heterogeneous multi-core memory system

Memory technology is one of the cornerstones of heterogeneous multi-core system efficiency. Many memory techniques are developed to give good performance within the lowest possible energy budget. These technologies open new opportunities for the memory system architecture that serves as the primary means for data storage and data sharing between multiple heterogeneous cores. In this paper, we study existing state of the art memories, discuss a conventional memory system and propose a novel hardware mechanism for heterogeneous multi-core memory system called Pattern Aware Memory System (PAMS). The PAMS supports static and dynamic data structures using descriptors and specialized scratchpad memory. In order to prove the proposed memory system, we implemented and tested it on real-prototype and simulator environments. The benchmarking results on real-prototype hardware show that PAMS achieves a maximum speedup of 12.83x and 1.23x for static and dynamic data structures respectively. When compared to the Baseline System, the PAMS consumes up to 4.8 times less program memory for static and dynamic data structures respectively. The PAMS consumes 4.6% and 1.6 times less dynamic power and energy respectively. The results of simulator environment show that the PAMS transfers data-structures up to 5.12x faster than the baseline system.

Error-Correcting Data Structures

We study data structures in the presence of adversarial noise. We want to encode a given object in a succinct data structure that enables us to efficiently answer specific queries about the object, even if the data structure has been corrupted by a constant fraction of errors. We measure the efficiency of a data structure in terms of its length (the number of bits in its representation) and query-answering time, measured by the number of bit-probes to the (possibly corrupted) representation. The main issue is the trade-off between these two. This new model is the common generalization of (static) data structures and locally decodable error-correcting codes (LDCs). We prove a number of upper and lower bounds on various natural error-correcting data structure problems. In particular, we show that the optimal length of $t$-probe error-correcting data structures for the Membership problem (where we want to store subsets of size $s$ from a universe of size $n$ such that membership queries can be answered effic...

A Space Lower Bound for Dynamic Approximate Membership Data Structures

An approximate membership data structure is a randomized data structure representing a set which supports membership queries. It allows for a small false positive error rate but has no false negative errors. Such data structures were first introduced by Bloom in the 1970s and have since had numerous applications, mainly in distributed systems, database systems, and networks. The algorithm of Bloom (known as a Bloom filter) is quite effective: it can store an approximation of a set $S$ of size $n$ by using only $\approx 1.44 n \log_2(1/\varepsilon)$ bits while having false positive error $\varepsilon$. This is within a constant factor of the information-theoretic lower bound of $n \log_2(1/\varepsilon)$ for storing such sets. Closing this gap is an important open problem, as Bloom filters are widely used in situations where storage is at a premium. Bloom filters have another property: they are dynamic. That is, they support the iterative insertions of up to $n$ elements. In fact, if one removes this requirement, there exist static data structures that receive the entire set at once and can almost achieve the information-theoretic lower bound; they require only $(1+o(1)) n \log_2(1/\varepsilon)$ bits. Our main result is a new lower bound for the space requirements of any dynamic approximate membership data structure. We show that for any constant $\varepsilon>0$, any such data structure that achieves false positive error rate of $\varepsilon$ must use at least $C(\varepsilon) \cdot n \log_2(1/\varepsilon)$ memory bits, where $C(\varepsilon)>1$ depends only on $\varepsilon$. This shows that the information-theoretic lower bound cannot be achieved by dynamic data structures for any constant error rate.

Dynamic clustering with soft computing

AbstractClustering methods are one of the most popular approaches to data mining. They have been successfully used in virtually any field covering domains such as economics, marketing, bioinformatics, engineering, and many others. The classic cluster algorithms require static data structures. However, there is an increasing need to address changing data patterns. On the one hand, this need is generated by the rapidly growing amount of data that is collected by modern information systems and that has led to an increasing interest in data mining as its whole again. On the other hand, modern economies and markets do not deal with stable settings any longer but are facing the challenge to adapt to constantly changing environments. These include seasonal changes but also long‐term trends that structurally change whole economies, wipe out companies that cannot adapt to these trends, and create opportunities for entrepreneurs who establish large multinational corporations virtually out of nothing in just one decade or two. Hence, it is essential for almost any organization to address these changes. Obviously, players that have information on changes first possibly obtain a strategic advantage over their competitors. This has motivated an increasing number of researchers to enrich and extend classic static clustering algorithms by dynamic derivatives. In the past decades, very promising approaches have been suggested; some selected ones will be introduced in this review. © 2012 Wiley Periodicals, Inc.This article is categorized under: Algorithmic Development > Spatial and Temporal Data Mining Algorithmic Development > Structure Discovery Technologies > Computational Intelligence Technologies > Structure Discovery and Clustering

Low-contention data structures

We consider the problem of minimizing contention in static (read-only) dictionary data structures, where contention is measured with respect to a fixed query distribution by the maximum expected number of probes to any given cell. The query distribution is known by the algorithm that constructs the data structure but not by the algorithm that queries it. Assume that the dictionary has n items. When all queries in the dictionary are equiprobable, and all queries not in the dictionary are equiprobable, we show how to construct a data structure in O(n) space where queries require O(1) probes and the contention is O(1/n). Asymptotically, all of these quantities are optimal. For arbitrary query distributions, we construct a data structure in O(n) space where each query requires O(logn/loglogn) probes and the contention is O(logn/(nloglogn)). The lack of knowledge of the query distribution by the query algorithm prevents perfect load leveling in this case: for a large class of algorithms, we present a lower bound, based on VC-dimension, that shows that for a wide range of data structure problems, achieving contention even within a polylogarithmic factor of optimal requires a cell-probe complexity of Ω(loglogn).

Cell-Probe Proofs

We study the nondeterministic cell-probe complexity of static data structures. We introduce cell-probe proofs (CPP), a proof system for the cell-probe model, which describes verification instead of computation in the cell-probe model. We present a combinatorial characterization of CPP. With this novel tool, we prove the following lower bounds for the nondeterministic cell-probe complexity of static data structures. –There exists a data structure problem with high nondeterministic cell-probe complexity. –For the exact nearest neighbor search (NNS) problem or the partial match problem in high dimensional Hamming space, for any data structure with Poly( n ) cells, each of which contains O ( n C ) bits where C < 1, the nondeterministic cell-probe complexity is at least Ω(log( d /log n )), where d is the dimension and n is the number of points in the data set. –For the polynomial evaluation problem of d -degree polynomial over finite field of size 2 k where d ≤ 2 k , for any data structure with s cells, each of which contains b bits, the nondeterministic cell-probe complexity is at least min (( k / b ( d − 1)), ( k −log( d −1)/log s )).

Matching-based preprocessing algorithms to the solution of saddle-point problems in large-scale nonconvex interior-point optimization

Interior-point methods are among the most efficient approaches for solving large-scale nonlinear programming problems. At the core of these methods, highly ill-conditioned symmetric saddle-point problems have to be solved. We present combinatorial methods to preprocess these matrices in order to establish more favorable numerical properties for the subsequent factorization. Our approach is based on symmetric weighted matchings and is used in a sparse direct LDL T factorization method where the pivoting is restricted to static supernode data structures. In addition, we will dynamically expand the supernode data structure in cases where additional fill-in helps to select better numerical pivot elements. This technique can be seen as an alternative to the more traditional threshold pivoting techniques. We demonstrate the competitiveness of this approach within an interior-point method on a large set of test problems from the CUTE and COPS sets, as well as large optimal control problems based on partial differential equations. The largest nonlinear optimization problem solved has more than 12 million variables and 6 million constraints.

I/O-efficient dynamic planar point location

We present an I/O-efficient dynamic data structure for point location in a general planar subdivision. Our structure uses O( N/ B) disk blocks of size B to store a subdivision of size N. Queries can be answered in O(log B 2 N) I/Os in the worst-case, and insertions and deletions can be performed in O(log 2 B N) and O(log B N) I/Os amortized, respectively. Part of our data structure is based on an external version of the so-called logarithmic method that allows for efficient dynamization of static external-memory data structures with certain characteristics. Another important part of our structure is an external data structure for vertical ray-shooting among line segments in the plane with endpoints on B +1 vertical lines, developed using an external version of dynamic fractional cascading. We believe that these methods could prove helpful in the development of other dynamic external memory data structures.

Dynamic Data Structures for a Direct Search Algorithm

The DIRECT (DIviding RECTangles) algorithm of Jones, Perttunen, and Stuckman (Journal of Optimization Theory and Applications, vol. 79, no. 1, pp. 157–181, 1993), a variant of Lipschitzian methods for bound constrained global optimization, has proved effective even in higher dimensions. However, the performance of a DIRECT implementation in real applications depends on the characteristics of the objective function, the problem dimension, and the desired solution accuracy. Implementations with static data structures often fail in practice, since it is difficult to predict memory resource requirements in advance. This is especially critical in multidisciplinary engineering design applications, where the DIRECT optimization is just one small component of a much larger computation, and any component failure aborts the entire design process. To make the DIRECT global optimization algorithm efficient and robust on large-scale, multidisciplinary engineering problems, a set of dynamic data structures is proposed here to balance the memory requirements with execution time, while simultaneously adapting to arbitrary problem size. The focus of this paper is on design issues of the dynamic data structures, and related memory management strategies. Numerical computing techniques and modifications of Jones' original DIRECT algorithm in terms of stopping rules and box selection rules are also explored. Performance studies are done for synthetic test problems with multiple local optima. Results for application to a site-specific system simulator for wireless communications systems (S4W) are also presented to demonstrate the effectiveness of the proposed dynamic data structures for an implementation of DIRECT.