Efficient plane sweeping in parallel

Techniques for parallel divide-and-conquer are presented, resulting in improved parallel algorithms for a number of problems. The problems for which improved algorithms are given include segment intersection detection, trapezoidal decomposition, and planar point location. Efficient parallel algorithms are algo given for fractional cascading, three-dimensional maxima, two-set dominance counting, and visibility from a point. All of the algorithms presented run in $O(\log n)$ time with either a linear or a sublinear number of processors in the CREW PRAM model.

Highly efficient parallel algorithms for solving the Bates PIDE for pricing options on a GPU

In the past ten years, there have been a number of data structures that, given a distribution of planar point location queries, produce a planar point location data structure that is tuned for the provided distribution. These structures all suffer from the requirement that the query distribution be provided in advance. For the problem of point location in a triangulation, a data structure is presented that performs asymptotically as well as these structures, but does not require the distribution to be provided in advance. This result is the 2-d analogue of the jump from the optimum binary search trees of Knuth in 1971 which required that the distribution be provided, to the splay trees of Sleator and Tarjan in 1985 where in the static optimality theorem it was proven that splay trees had the same asymptotic performance of optimum search trees without being provided the probability distribution.

The motif finding problem is one of the important and challenging problems in bioinformatics. A variety of sequential algorithms have been proposed to find exact motifs, but the running time is still not suitable due to high computational complexity of finding motifs. In this paper we parallelize three efficient sequential algorithms which are HEPPMSprune, PMS5 and PMS6. We implement the algorithms on a Dual Quad-Core machine using openMP to measure the performance of each algorithm. Our experiment on simulated data show that: (1) the parallel PMS6 is faster than the other algorithms in case of challenging instances, while the parallel HEPPMSprune is faster than the other algorithms in most of solvable instances; (2) the scalability of parallel HEPPMSprune is linear for all instances, while the scalability of parallel PMS5 and PMS6 is linear in case of challenging instances only; (3) the memory used by HEPPMSprune is less than that of the other algorithms.

Recall that MatchNum(G) is the size (number of edges) of a maximum cardinality matching of a graph G = (V, E) and a perfect matching is a matching of size IVl/2. There are two basic combinatorial tools needed to compute this number: augmenting paths (to construct a matching of a maximal size k); witness sets (to provide an NC-proof that there is no matching of size larger thank). Almost all efficient sequential algorithms use augmenting paths, contrary to NC¬ algorithms. On the other hand witness sets are not used frequently in sequential computations but they are needed in parallel randomized computations. If an algorithm returns a matching of cardinality k then we are not certain if this cardinality is the maximum possible, even if there is a very small probability of failure. Our algorithm is a Monte Carlo algorithm. A better situation occurs when the algorithm provides a maximum cardinality matching and an easy (checkable in NC) proof that it is maximum. In this case the algorithm becomes the so-called Las Vegas algorithm. If a matching is perfect then it gives the optimality proof by itself.

Inverse Pattern Matching

Upward and dominance drawings of acyclic digraphs find important applications in the display of hierarchical structures such as PERT diagrams, subroutine-call charts, and is-a relationships. The combinatorial model underlying such hierarchical structures is often a series-parallel digraph. In this paper the problem of constructing upward and dominance drawings of series-parallel digraphs is investigated. We show that the area requirement of upward and dominance drawings of series-parallel digraphs crucially depends on the choice of planar embedding. Also, we present efficient sequential and parallel algorithms for drawing series-parallel digraphs. Our results show that while series-parallel digraphs have a rather simple and well understood combinatorial structure, naive drawing strategies lead to drawings with exponential area, and clever algorithms are needed to achieve optimal area.

Inspired by the classical fractional cascading technique, we introduce new techniques to speed up the following type of iterated search in 3D: The input is a graph $\mathbf{G}$ with bounded degree together with a set $H_v$ of 3D hyperplanes associated with every vertex of $v$ of $\mathbf{G}$. The goal is to store the input such that given a query point $q\in \mathbb{R}^3$ and a connected subgraph $\mathbf{H}\subset \mathbf{G}$, we can decide if $q$ is below or above the lower envelope of $H_v$ for every $v\in \mathbf{H}$. We show that using linear space, it is possible to answer queries in roughly $O(\log n + |\mathbf{H}|\sqrt{\log n})$ time which improves trivial bound of $O(|\mathbf{H}|\log n)$ obtained by using planar point location data structures. Our data structure can in fact answer more general queries (it combines with shallow cuttings) and it even works when $\mathbf{H}$ is given one vertex at a time. We show that this has a number of new applications and in particular, we give improved solutions to a set of natural data structure problems that up to our knowledge had not seen any improvements. We believe this is a very surprising result because obtaining similar results for the planar point location problem was known to be impossible.

A segment tree is a versatile tree-based data structure over intervals or line segments efficiently supporting several computational operations such as stabbing query, segment arrangement, and planar point location, both theoretically and practically. Polygon clipping is a basic operation in domains such as Computer Graphics, Computer-aided Design, and Geographic Information Science (GIS). Given two polygons with n vertices, polygon clipping algorithms find the geometric intersection or union in <Formula format="inline"><TexMath><?TeX $\mathcal {O}(n^2)$?></TexMath><AltText>Math 1</AltText><File name="icpp24-103-inline1" type="svg"/></Formula> time using Foster’s all-to-all edge intersection testing and <Formula format="inline"><TexMath><?TeX $\mathcal {O}((n+k)\log n)$?></TexMath><AltText>Math 2</AltText><File name="icpp24-103-inline2" type="svg"/></Formula> time using Vatti’s sweep line-based method, where k is the number of intersections. No known segment tree implementation, including the CGAL library, supports intersection finding or polygon clipping. We extended the segment tree leveraging Chaselle’s PRAM-model augmentation, parallelized the construction of our augmented segment tree, and employed it to find line segment intersections for polygon clipping while handling degenerate cases. Augmented segment tree eliminates 99% of non-intersecting edge pairs compared to 63% by the state-of-the-art filtering based on common minimum bounding rectangle method employed in Foster’s GPU-based implementation. This, coupled with Ω(nlog n) work on a single CPU core, beats Foster’s GPU performance with <Formula format="inline"><TexMath><?TeX $\mathcal {O}(n^2)$?></TexMath><AltText>Math 3</AltText><File name="icpp24-103-inline3" type="svg"/></Formula> work. Our OpenMP directive based multi-core implementation achieves up to 4X relative speedup for clipping two polygons with 182K vertices and 5X speedup for five polygons with 398K vertices. We also offloaded the parallel kernels to a GPU using OpenACC achieving performance competitive with Foster’s GPU implementation. Our profiling indicates limitations of the compiler directives and potential for superior performance by employing pthread/cuda libraries.

A classical problem in computational geometry is the planar point location problem. This problem calls for preprocessing a polygonal subdivision of the plane defined by n line segments so that, given a sequence of points, the polygon containing each point can be determined quickly on-line. Several ways of solving this problem in O(log n) query time and O(n) space are known, but they are all rather complicated. We propose a simple O(log n)-query-time, O(n)-space solution, using persistent search trees. A persistent search tree differs from an ordinary search tree in that after an insertion or deletion, the old version of the tree can still be accessed. We develop a persistent form of binary search tree that supports insertions and deletions in the present and queries in the past. The time per query or update is O(log m), where m is the total number of updates, and the space needed is O(1) per update. Our planar point location algorithm is an immediate application of this data structure. The structure also provides an alternative to Chazelle's hive graph structure, which has a variety of applications in geometric retrieval.

We give a number of new lower bounds in the cell probe model&lt;br /&gt;with logarithmic cell size, which entails the same bounds on the random access computer with logarithmic word size and unit cost operations. We study the signed prefix sum problem: given a string of length n of zeroes and signed ones, compute the sum of its ith prefix during updates. We show a&lt;br /&gt;lower bound of Omega(log n/log log n) time per operations, even if the prefix sums are bounded by log n/log log n during all updates. We also show that if the update time is bounded by the product of the worst-case update time and the&lt;br /&gt;answer to the query, then the update time must be Omega(sqrt(log n/ log log n)).&lt;br /&gt; These results allow us to prove lower bounds for a variety of seemingly unrelated&lt;br /&gt;dynamic problems. We give a lower bound for the dynamic planar point location in monotone subdivisions of &lt;br /&gt;Omega(log n/ log log n) per operation. We give&lt;br /&gt;a lower bound for the dynamic transitive closure problem on upward planar graphs with one source and one sink of &lt;br /&gt;Omega(log n/(log logn)^2) per operation. We give a lower bound of Omega(sqrt(log n/log log n)) for the dynamic membership problem of any Dyck language with two or more letters. This implies the same&lt;br /&gt;lower bound for the dynamic word problem for the free group with k generators. We also give lower bounds for the dynamic prefix majority and prefix equality problems.

We develop a numerically efficient algorithm for computing controls for nonlinear systems that minimize a quadratic performance measure. We formulate the optimal control problem in discrete-time, but many continuous-time problems can be also solved after discretization. Our approach is similar to sequential quadratic programming for finite-dimensional optimization problems in that we solve the nonlinear optimal control problem using sequence of linear quadratic subproblems. Each subproblem is solved efficiently using the Riccati difference equation. We show that each iteration produces a descent direction for the performance measure, and that the sequence of controls converges to a solution that satisfies the well-known necessary conditions for the optimal control.

Small sample spaces with almost independent random variables are applied to design efficient sequential deterministic algorithms for two problems. The first algorithm, motivated by the attempt to design efficient algorithms for the All Pairs Shortest Path problem using fast matrix multiplication, solves the problem of computingwitnesses for the Boolean product of two matrices. That is, ifA andB are twon byn matrices, andC=AB is their Boolean product, the algorithm finds for every entryC ij =1 a witness: an indexk so thatA ik =B kj =1. Its running time exceeds that of computing the product of twon byn matrices with small integer entries by a polylogarithmic factor. The second algorithm is a nearly linear time deterministic procedure for constructing a perfect hash function for a givenn-subset of {1,...,m}.

We consider the recovery of sparse signals, f ∈ ℝN, containing at most k ≪ N nonzero entries using linear measurements contaminated with i.i.d. Gaussian background noise. Given this measurement model, we present and analyze a computationally efficient group testing strategy for recovering the support of f and approximating its nonzero entries. In particular, we demonstrate that group testing measurement matrix constructions may be combined with statistical binary detection and estimation methods to produce efficient adaptive sequential algorithms for sparse signal support recovery. Furthermore, when f exhibits sufficient sparsity, we show that these adaptive group testing methods allow the recovery of sparse signals using fewer noisy linear measurements than possible with non-adaptive methods based on Gaussian measurement ensembles. As a result we improve on previous sufficient conditions for sparsity pattern recovery in the noisy sublinear-sparsity regime.

This chapter presents a sequential Monte Carlo data association algorithm for tracking a varying number of interacting objects in a dynamic scene. The algorithm is based on a computational framework that consists of a hybrid measurement process, a Monte Carlo joint probabilistic data association filter, and a particle-based belief propagation algorithm. The hybrid measurement process addresses problems associated with having a varying number of objects. It does so by mixing target-driven measurements provided by a prior model of target dynamics and data-driven measurements based on a discriminative model; the Monte Carlo joint probabilistic data association filter combats the curse of dimensionality by providing a marginal posterior distribution for each individual target; and particle-based belief propagation is used to deal with occlusions among objects.Within this framework, the learning of discriminative model, the Monte Carlo joint data association filtering, and belief propagation are realized as different levels of approximation to the ‘ideal’ generative model inherent in the problem of tracking multiple visual objects. Together, these result in an efficient sequential Monte Carlo data association algorithm. The algorithm is illustrated via the tracking of multiple pedestrians in several real-life test videos. Empirical results demonstrate the algorithm’s efficiency in a number of test situations.