Inconstancy of finite and infinite sequences

In order to study large variations or fluctuations of finite or infinite sequences (time series), we bring to light an 1868 paper of Crofton and the (Cauchy-)Crofton theorem. After surveying occurrences of this result in the literature, we introduce the inconstancy of a sequence and we show why it seems more pertinent than other criteria for measuring its variational complexity. We also compute the inconstancy of classical binary sequences including some automatic sequences and Sturmian sequences.Comment: Accepted by Theoretical Computer Scienc

Approximate Data Structures with Applications

In this paper we introduce the notion of approximate data structures, in which a small amount of error is tolerated in the output. Approximate data structures trade error of approximation for faster operation, leading to theoretical and practical speedups for a wide variety of algorithms. We give approximate variants of the van Emde Boas data structure, which support the same dynamic operations as the standard van Emde Boas data structure [28, 201, except that answers to queries are approximate. The variants support all operations in constant time provided the error of approximation is l/polylog(n), and in O(loglog n) time provided the error is l/polynomial(n), for n elements in the data structure. We consider the tolerance of prototypical algorithms to approximate data structures. We study in particular Prim’s minimumspanning tree algorithm, Dijkstra’s single-source shortest paths algorithm, and an on-line variant of Graham’s convex hull algorithm. To obtain output which approximates the desired output with the error of approximation tending to zero, Prim’s algorithm requires only linear time, Dijkstra’s algorithm requires O(mloglogn) time, and the on-line variant of Graham’s algorithm requires constant amortized time per operation

A Streaming Algorithm for the Convex Hull

Consider a base station in a wireless sensor network that receives incoming input points and must maintain a running convex hull within a memory constraint. We give a new streaming algorithm that processes each point in time O (log k) where k is the memory constraint, while maintaining an optimal area error of O(1/k²)

Convex hulls of spheres and convex hulls of convex polytopes lying on parallel hyperplanes

Given a set $\Sigma$ of spheres in $\mathbb{E}^d$, with $d\ge{}3$ and $d$ odd, having a fixed number of $m$ distinct radii $\rho_1,\rho_2,...,\rho_m$, we show that the worst-case combinatorial complexity of the convex hull $CH_d(\Sigma)$ of $\Sigma$ is $\Theta(\sum_{1\le{}i\ne{}j\le{}m}n_in_j^{\lfloor\frac{d}{2}\rfloor})$, where $n_i$ is the number of spheres in $\Sigma$ with radius $\rho_i$. To prove the lower bound, we construct a set of $\Theta(n_1+n_2)$ spheres in $\mathbb{E}^d$, with $d\ge{}3$ odd, where $n_i$ spheres have radius $\rho_i$, $i=1,2$, and $\rho_2\ne\rho_1$, such that their convex hull has combinatorial complexity $\Omega(n_1n_2^{\lfloor\frac{d}{2}\rfloor}+n_2n_1^{\lfloor\frac{d}{2}\rfloor})$. Our construction is then generalized to the case where the spheres have $m\ge{}3$ distinct radii. For the upper bound, we reduce the sphere convex hull problem to the problem of computing the worst-case combinatorial complexity of the convex hull of a set of $m$ $d$-dimensional convex polytopes lying on $m$ parallel hyperplanes in $\mathbb{E}^{d+1}$, where $d\ge{}3$ odd, a problem which is of independent interest. More precisely, we show that the worst-case combinatorial complexity of the convex hull of a set $\{\mathcal{P}_1,\mathcal{P}_2,...,\mathcal{P}_m\}$ of $m$ $d$-dimensional convex polytopes lying on $m$ parallel hyperplanes of $\mathbb{E}^{d+1}$ is $O(\sum_{1\le{}i\ne{}j\le{}m}n_in_j^{\lfloor\frac{d}{2}\rfloor})$, where $n_i$ is the number of vertices of $\mathcal{P}_i$. We end with algorithmic considerations, and we show how our tight bounds for the parallel polytope convex hull problem, yield tight bounds on the combinatorial complexity of the Minkowski sum of two convex polytopes in $\mathbb{E}^d$.Comment: 22 pages, 5 figures, new proof of upper bound for the complexity of the convex hull of parallel polytopes (the new proof gives upper bounds for all face numbers of the convex hull of the parallel polytopes

Two Approaches to Building Time-Windowed Geometric Data Structures

Given a set of geometric objects each associated with a time value, we wish to determine whether a given property is true for a subset of those objects whose time values fall within a query time window. We call such problems time-windowed decision problems, and they have been the subject of much recent attention, for instance studied by Bokal, Cabello, and Eppstein [SoCG 2015]. In this paper, we present new approaches to this class of problems that are conceptually simpler than Bokal et al.\u27s, and also lead to faster algorithms. For instance, we present algorithms for preprocessing for the time-windowed 2D diameter decision problem in O(n log n) time and the time-windowed 2D convex hull area decision problem in O(n alpha(n) log n) time (where alpha is the inverse Ackermann function), improving Bokal et al.\u27s O(n log^2 n) and O(n log n loglog n) solutions respectively. Our first approach is to reduce time-windowed decision problems to a generalized range successor problem, which we solve using a novel way to search range trees. Our other approach is to use dynamic data structures directly, taking advantage of a new observation that the total number of combinatorial changes to a planar convex hull is near linear for any FIFO update sequence, in which deletions occur in the same order as insertions. We also apply these approaches to obtain the first O(n polylog n) algorithms for the time-windowed 3D diameter decision and 2D orthogonal segment intersection detection problems

Convex Hulls, Triangulations, and Voronoi Diagrams of Planar Point Sets on the Congested Clique

We consider geometric problems on planar $n^2$-point sets in the congested clique model. Initially, each node in the $n$-clique network holds a batch of $n$ distinct points in the Euclidean plane given by $O(\log n)$-bit coordinates. In each round, each node can send a distinct $O(\log n)$-bit message to each other node in the clique and perform unlimited local computations. We show that the convex hull of the input $n^2$-point set can be constructed in $O(\min\{ h,\log n\})$ rounds, where $h$ is the size of the hull, on the congested clique. We also show that a triangulation of the input $n^2$-point set can be constructed in $O(\log^2n)$ rounds on the congested clique. Finally, we demonstrate that the Voronoi diagram of $n^2$ points with $O(\log n)$-bit coordinates drawn uniformly at random from a unit square can be computed within the square with high probability in $O(1)$ rounds on the congested clique.Comment: 17 pages, 7 figure

Dynamic Convex Hulls under Window-Sliding Updates

We consider the problem of dynamically maintaining the convex hull of a set $S$ of points in the plane under the following special sequence of insertions and deletions (called {\em window-sliding updates}): insert a point to the right of all points of $S$ and delete the leftmost point of $S$. We propose an $O(|S|)$-space data structure that can handle each update in $O(1)$ amortized time, such that standard binary-search-based queries on the convex hull of $S$ can be answered in $O(\log h)$ time, where $h$ is the number of vertices of the convex hull of $S$, and the convex hull itself can be output in $O(h)$ time.Comment: A previous version appeared in WADS 2023, where the query time was O(log |S|). This new version improves the query time to O(log h

An efficient output-sensitive hidden surface removal algorithm and its parallelization

In this paper we present an algorithm for hidden surface removal for a class of polyhedral surfaces which have a property that they can be ordered relatively quickly like the terrain maps. A distinguishing feature of this algorithm is that its running time is sensitive to the actual size of the visible image rather than the total number of intersections in the image plane which can be much larger than the visible image. The time complexity of this algorithm is O((k +nflognloglogn) where n and k are respectively the input and the output sizes. Thus, in a significant number of situations this will be faster than the worst case optimal algorithms which have running time Ω(n 2) irrespective of the output size (where as the output size k is O(n 2) only in the worst case). We also present a parallel algorithm based on a similar approach which runs in time O(log4(n+k)) using O((n + k)/Iog(n+k)) processors in a CREW PRAM model. All our bounds arc obtained using ammortized analysis

How to Cover a Point Set with a V-Shape of Minimum Width

A balanced V-shape is a polygonal region in the plane contained in the union of two crossing equal-width strips. It is delimited by two pairs of parallel rays that emanate from two points x, y, are contained in the strip boundaries, and are mirror-symmetric with respect to the line xy. The width of a balanced V-shape is the width of the strips. We first present an O(n^2 log n) time algorithm to compute, given a set of n points P, a minimum-width balanced V-shape covering P. We then describe a PTAS for computing a (1+epsilon)-approximation of this V-shape in time O((n/epsilon)log n+(n/epsilon^(3/2))log^2(1/epsilon)). A much simpler constant-factor approximation algorithm is also described.Comment: In Proceedings of the 12th International Symposium on Algorithms and Data Structures (WADS), p.61-72, August 2011, New York, NY, US