Computational geometry

We give a deterministic algorithm for triangulating a simple polygon in linear time. The basic strategy is to build a coarse approximation of a triangulation in a bottom-up phase and then use the information computed along the way to refine the triangulation in a top-down phase. The main tools used are the polygon-cutting theorem, which provides us with a balancing scheme, and the planar separator theorem, whose role is essential in the discovery of new diagonals. Only elementary data structures are required by the algorithm. In particular, no dynamic search trees, of our algorithm.

Triangulating a simple polygon in linear time

Computational geometry.

Origami describes rules for creating folded structures from patterns on a flat sheet, but does not prescribe how patterns can be designed to fit target shapes. Here, starting from the simplest periodic origami pattern that yields one-degree-of-freedom collapsible structures-we show that scale-independent elementary geometric constructions and constrained optimization algorithms can be used to determine spatially modulated patterns that yield approximations to given surfaces of constant or varying curvature. Paper models confirm the feasibility of our calculations. We also assess the difficulty of realizing these geometric structures by quantifying the energetic barrier that separates the metastable flat and folded states. Moreover, we characterize the trade-off between the accuracy to which the pattern conforms to the target surface, and the effort associated with creating finer folds. Our approach enables the tailoring of origami patterns to drape complex surfaces independent of absolute scale, as well as the quantification of the energetic and material cost of doing so.

Programming curvature using origami tessellations

Voting based extreme learning machine

The high computational throughput of modern graphics processing units (GPUs) make them the de-facto architecture for high-performance computing applications. However, to achieve peak performance, GPUs require highly parallel workloads, as well as memory access patterns that exhibit good locality of reference. As a result, many state-of-the-art algorithms and data structures designed for GPUs sacrifice work-optimality to achieve the necessary parallelism. Furthermore, some abstract data types are avoided completely due to there being no corresponding data structure that performs well on the GPU. One such abstract data type is the priority queue. Many well-known algorithms rely on priority queue operations as a building block. While various priority queue structures have been developed that are parallel, cache-aware, or cache-oblivious, none has been shown to be efficient on GPUs. In this paper, we present the parBucketHeap, a parallel, cache-efficient data structure designed for modern GPU architectures that supports standard priority queue operations, as well as bulk update. We analyze the structure in several well-known computational models and show that it provides both optimal parallelism and is cache-efficient. We implement the parBucketHeap and, using it, we solve the single-source shortest path (SSSP) problem. Experimental results indicate that, for sufficiently large, dense graphs with high diameter, we out-perform current state-of-the-art SSSP algorithms on the GPU by up to a factor of 5. Unlike existing GPU SSSP algorithms, our approach is work-optimal and places significantly less load on the GPU, reducing power consumption.

A parallel priority queue with fast updates for GPU architectures.

We consider the problem of maintaining an approximate maximum independent set of geometric objects under insertions and deletions. We present a data structure that maintains a constant-factor approximate maximum independent set for broad classes of fat objects in d dimensions, where d is assumed to be a constant, in sublinear worst-case update time. This gives the first results for dynamic independent set in a wide variety of geometric settings, such as disks, fat polygons, and their high-dimensional equivalents. For axis-aligned squares and hypercubes, our result improves upon all (recently announced) previous works. We obtain, in particular, a dynamic (4+e)-approximation for squares, with O(log⁴ n) worst-case update time. 
Our result is obtained via a two-level approach. First, we develop a dynamic data structure which stores all objects and provides an approximate independent set when queried, with output-sensitive running time. We show that via standard methods such a structure can be used to obtain a dynamic algorithm with amortized update time bounds. Then, to obtain worst-case update time algorithms, we develop a generic deamortization scheme that with each insertion/deletion keeps (i) the update time bounded and (ii) the number of changes in the independent set constant. We show that such a scheme is applicable to fat objects by showing an appropriate generalization of a separator theorem. 
Interestingly, we show that our deamortization scheme is also necessary in order to obtain worst-case update bounds: If for a class of objects our scheme is not applicable, then no constant-factor approximation with sublinear worst-case update time is possible. We show that such a lower bound applies even for seemingly simple classes of geometric objects including axis-aligned rectangles in the plane.

https://drops.dagstuhl.de/opus/volltexte/2021/14606/pdf/LIPIcs-ESA-2021-25.pdf/

Worst-Case Efficient Dynamic Geometric Independent Set

We present priority queues in the external memory model with block size $B$ and main memory size $M$ that support on $N$ elements, operation Update (a combination of operations Insert and Decrease-Key) in $O\left( \frac{1}{B}\log_{\frac{M}{B}} \frac{N}{B}\right)$ amortized I/Os and operations Extract-Min and Delete in $O\left( \lceil \frac{M^{\varepsilon}}{B} \log_{\frac{M}{B}} \frac{N}{B} \rceil \log_{\frac{M}{B}} \frac{N}{B}\right)$ amortized I/Os, for any real $\varepsilon \in \left(0,1\right)$, using $O\left( \frac{N}{B}\log_{\frac{M}{B}} \frac{N}{B}\right)$ blocks. Previous I/O-efficient priority queues either support these operations in $O\left(\frac{1}{B}\log_2 \frac{N}{B}\right)$ amortized I/Os [Kumar and Schwabe, SPDP '96] or support only operations Insert, Delete and Extract-Min in optimal $O\left( \frac{1}{B}\log_{\frac{M}{B}} \frac{N}{B}\right) $ amortized I/Os, however without supporting Decrease-Key [Fadel et al., TCS '99]. 
We also present buffered repository trees that support on a multi-set of $N$ elements, operation Insert in $O\left(\frac{1}{B}\log_{\frac{M}{B}} \frac{N}{B}\right)$ I/Os and operation Extract on $K$ extracted elements in $O\left( M^{\varepsilon}\log_{\frac{M}{B}} \frac{N}{B} + K/B\right)$ amortized I/Os, using $O \left(\frac{N}{B}\right)$ blocks. Previous results achieve $O\left(\frac{1}{B}\log_2 \frac{N}{B}\right)$ I/Os and $O\left( \log_2 \frac{N}{B} + \frac{K}{B}\right)$ I/Os, respectively [Buchsbaum et al., SODA '00]. 
Our results imply improved $O\left(\frac{E}{B}\log_{\frac{M}{B}} \frac{E}{B}\right)$ I/Os for single-source shortest paths, depth-first search and breadth-first search algorithms on massive directed dense graphs $\left(V,E\right)$ with $E = \Omega \left( V^{1+\varepsilon}\right), \varepsilon > 0$ and $V = \Omega \left( M \right)$, which is equal to the I/O-optimal bound for sorting $E$ values in external memory.

External memory priority queues with decrease-key and applications to graph algorithms

We show how to detect duplicates in a sequence of k n-bit vectors presented as a list of single-bit changes between consecutive vectors, in O((n + k) log n) time. Problem We are given a sequence S = {v1, . . . , vk} of k n-bit vectors, presented as follows: The first bit vector is all zeros and each subsequent vector vi is obtained from the previous vector vi−1 by flipping a single bit in position bi, 0 ≤ bi < n. S is represented as b2, b3, . . . , bk. The problem is to detect duplicates in the sequence v1, v2, . . . , vk. More formally, we seek a labeling S → {1, . . . , k}, vi 7→ ci, such that ci = cj iff vi = vj . Solution Without loss of generality in the remainder of this note we assume that n is a power of two. Let T be the perfectly balanced binary tree on n leaves. We number the leaves of T from 0 to n− 1 and associate each with a bit position. Each interior node x of T is similarly associated with a block B(x) of consecutive bit positions corresponding to the leaves of the subtree rooted at x. For a bit vector vi, let vi(x) be its substring in B(x). The idea behind our data structure is simple: each node x has an associated data structure that stores implicitly the set ⋃k i=1{vi(x)}. The data structure stored at node x consists of two arrays Dx and Fx that store the following data: • Dx[1, . . . , dx] contains the sorted set including 1 and all distinct values i, 1 < i ≤ k, such that vi−1(x) 6= vi(x). • Fx[1, . . . , dx] contains integers in the range 1, . . . , dx with the property that Fx[i] = Fx[j] iff vDx[i](x) = vDx[j](x). 1Research supported in part by NSF ITR Grant CCR-0081964 and by a grant from US-Israel Binational Science Foundation; part of work has been carried out while visiting MaxPlanck-Institut für Informatik. Department of Computer and Information Science, Polytechnic University, 5 MetroTech Center, Brooklyn, NY 11201 USA; http://cis.poly.edu/ ̃aronov. 2Research supported in part by NSF grant CCF-0430849. Department of Computer and Information Science, Polytechnic University, 5 MetroTech Center, Brooklyn, NY 11201 USA; http://john.poly.edu. We now complete the description of our algorithm, by explaining how to initialize Dz and Fz for all leaves z ∈ T and how to compute Dx and Fx from Dl, Fr, Dl, Fr for any internal node x with children l and r. Froot describes the desired labeling of S, since Droot contains all the numbers 1, . . . , k. If one stores all of the leaves z in an array in numerical order, a linear scan of the sequence b2, b3, . . . , bk of bit updates allows one to initialize arrays Dz and Fz, for all z. Specifically, we store the current bit vector vi−1 explicitly in a bit array V [0, . . . , n − 1]. Since bi = j indicates a bit flip in position z = j (recall that bit positions, and thus leaves are identified with integers 0, . . . , n− 1), we flip the value of V [j], add j to Dz, and depending on the resulting value of V [j], set the next entry in Fz to zero or one. Algorithm 1 The pseudocode for computing Dx, Fx from Dl, Fl, Dr, Fr. 1: i← j ← k ← 1 2: Dl[dl + 1]← DR[dr + 1]←∞ 3: repeat 4: Px[k]← (Fr(i), Fl(j), k, 0) 5: if Dl[i] < Dr[j] then 6: Dx[k]← Dl[i]; i← i + 1 7: else if Dl[i] = Dr[j] then 8: Dx[k]← Dl[i]; i← i + 1; j ← j + 1; 9: else if Dl[i] > Dr[j] then 10: Dx[k]← Dr[j]; j ← j + 1; 11: end if 12: k ← k + 1; 13: until i = dl + 1 and j = dr + 1 14: dx ← k − 1 . dx is the length of Px and Dx 15: Sort Px lexicographically on the first two fields, by radix sort 16: for k ← 2 to dx do 17: if Px[k − 1][1] = Px[k][1] and Px[k − 1][2] = Px[k][2] then 18: Px[k][4]← Px[k − 1][4] 19: else 20: Px[k][4]← Px[k − 1][4] + 1 21: end if 22: end for 23: for k ← 1 to dx do 24: Fx[Px[k][3]]← Px[k][4] 25: end for Now, we describe, for an internal node x of T with children l and r, how to construct Dx, Fx from arrays Dl, Dr, Fl, Fr; see Algorithm 1. The new sorted array Dx[1, . . . , dx] is built by merging the arrays Dl and Dr, eliminating any duplicates, in time O(dl + dr) =

Detecting duplicates among similar bit vectors

Over the last decade, there have been several data structures that, given a planar subdivision and a probability distribution over the plane, provide a way for answering point location queries that is fine-tuned for the distribution. All these methods suffer from the requirement that the query distribution must be known in advance. 
We present a new data structure for point location queries in planar triangulations. Our structure is asymptotically as fast as the optimal structures, but it requires no prior information about the queries. This is a 2D analogue of the jump from Knuth's optimum binary search trees (discovered in 1971) to the splay trees of Sleator and Tarjan in 1985. While the former need to know the query distribution, the latter are statically optimal. This means that we can adapt to the query sequence and achieve the same asymptotic performance as an optimum static structure, without needing any additional information.

John Iacono

Papers

A parallel priority queue with fast updates for GPU architectures.

Worst-Case Efficient Dynamic Geometric Independent Set

External memory priority queues with decrease-key and applications to graph algorithms

Detecting duplicates among similar bit vectors

A Static Optimality Transformation with Applications to Planar Point Location