Preprocessing Imprecise Points and Splitting Triangulations

Introduced by Agarwal, Har-Peled, and Varadarajan [J. ACM, 2004], an epsilon-kernel of a point set is a coreset that can be used to approximate the width, minimum enclosing cylinder, minimum bounding box, and solve various related geometric optimization problems. Such coresets form one of the most important tools in the design of linear-time approximation algorithms in computational geometry, as well as efficient insertion-only streaming algorithms and dynamic (non-streaming) data structures. In this paper, we continue the theme and explore dynamic streaming algorithms (in the so-called turnstile model). Andoni and Nguyen [SODA 2012] described a dynamic streaming algorithm for maintaining a (1+epsilon)-approximation of the width using O(polylog U) space and update time for a point set in [U]^d for any constant dimension d and any constant epsilon>0. Their sketch, based on a polynomial method, does not explicitly maintain an epsilon-kernel. We extend their method to maintain an epsilon-kernel, and at the same time reduce some of logarithmic factors. As an application, we obtain the first randomized dynamic streaming algorithm for the width problem (and related geometric optimization problems) that supports k outliers, using poly(k, log U) space and time.

The colored toy cubes contain all the information about the complex dynamics of cellular automata. An important advantage of the Boolean cube representation is that it allows us to define an index of complexity (Chua et al. 2002). Each one of the 256 cubes is obviously characterized by different clusters of red or blues vertices which can be separated by parallel planes. On the other hand, the separating planes can be analytically defined in the coordinate system of the Boolean cubes. Therefore, the complexity index of a cellular automaton with local rule N is defined by the minimum number of parallel planes needed to separate the red vertices of the corresponding Boolean cube N from the blue vertices. Figure 1 shows three examples of Boolean cubes for the three possible complexity indices κ = 1, 2, 3 with one, two and three separating parallel planes. There are 104 local rules with complexity index κ = 1. Similarly, there are 126 local rules with complexity index κ = 2, and only 26 local rules with complexity index κ = 3. This analytically defined complexity index is to be distinguished from Wolfram’s complexity index based on phenomenological estimations of pattern formation.

This paper has two goals. First, we point out that most problems in computational geometry in fact have fast parallel algorithms (that is, in NC*) by reduction to the cell decomposition result of Kozen and Yap. We illustrate this using a new notion of generalized Voronoi diagrams that subsumes all known instances. While the existence of NC* algorithms for computational geometry is theoretically significant, it leaves much to be desired for specific problems. Therefore, the second part of the paper surveys some recent results in a fast growing list of parallel algorithms for computational geometry.

The landing site decision has direct relation to the safety of a spacecraft. This paper presents the use of computational geometry (CG) and genetic algorithm (GA) in the landing site selection. In order to describe the obstacles, we use computational geometry to compute the minimum enclosing circles and ellipses. Taking the obstacles as discrete circles and ellipses, we use the genetic algorithm to simplify and to solve the difficult problem of finding the largest empty circle (LEC) in circles and ellipses for the spacecraft landing on the surface. The results of tests on the solution procedure are presented.

We consider a collectionH ofn hyperplanes in Ed (where the dimensiond is fixed). An ?-cutting forH is a collection of (possibly unbounded)d-dimensional simplices with disjoint interors, which cover all Ed and such that the interior of any simplex is intersected by at most?n hyperplanes ofH. We give a deterministic algorithm for finding a (1/r)-cutting withO(rd) simplices (which is asymptotically optimal). Forr≤n1??, where ?>0 is arbitrary but fixed, the running time of this algorithm isO(n(logn)O(1)rd?1). In the plane we achieve a time boundO(nr) forr≤n1??, which is optimal if we also want to compute the collection of lines intersecting each simplex of the cutting. This improves a result of Agarwal, and gives a conceptually simpler algorithm. For ann point setX⊆Ed and a parameterr, we can deterministically compute a (1/r)-net of sizeO(rlogr) for the range space (X, {X ? R; R is a simplex}), In timeO(n(logn)O(1)rd?1+rO(1)). The size of the (1/r)-net matches the best known existence result. By a simple transformation, this allows us to find ?-nets for other range spaces usually encountered in computational geometry. These results have numerous applications for derandomizing algorithms in computational geometry without affecting their running time significantly.

Solid modelling and computational geometry are based on classical topology and geometry in which the basic predicates and operations, such as membership, subset inclusion, union and intersection, are not continuous and therefore not computable. But a sound computational framework for solids and geometry can only be built in a framework with computable predicates and operations. In practice, correctness of algorithms in computational geometry is usually proved using the unrealistic Real RAM machine model of computation, which allows comparison of real numbers, with the undesirable result that correct algorithms, when implemented, turn into unreliable programs. Here, we use a domain-theoretic approach to recursive analysis to develop the basis of an e3ective and realistic framework for solid modelling. This framework is equipped with a well de5ned and realistic notion of computability which re6ects the observable properties of real solids. The basic predicates and operations on solids are computable in this model which admits regular and non-regular sets and supports a design methodology for actual robust algorithms. Moreover, the model is able to capture the uncertainties of input data in actual CAD situations. c 2002 Elsevier Science B.V. All rights reserved.

We study the Open image in new window (shortly, Open image in new window ) problem on geometric intersection graphs such as interval, circular-arc, permutation, unit-disk, outer-string graphs, etc. Given a Open image in new window graph \(G=(V,E)\), where each vertex in V is colored with either “ Open image in new window ” or “ Open image in new window ”, the BCS problem seeks a maximum cardinality induced connected subgraph H of G such that H is Open image in new window , i.e., H contains an equal number of red and blue vertices. We study the computational complexity landscape of the BCS problem while considering geometric intersection graphs. On one hand, we prove that the BCS problem is NP-hard on the unit disk, outer-string, complete grid, and unit square graphs. On the other hand, we design polynomial-time algorithms for the BCS problem on interval, circular-arc and permutation graphs. In particular, we give algorithms for the Open image in new window problem on both interval and circular-arc graphs, and those algorithms are used as subroutines for solving the BCS problem on the same classes of graphs. Finally, we present a FPT algorithm for the BCS problem on general graphs.

Algorithms in computational geometry often use the real-RAM model of computation. This model assumes that exact real numbers can be stored in memory and retreived in constant time, and that field operations (+, –, *, /) and certain other operations, square root, sine, and cosine for instance, are exact, and can be applied in constant time. These assumptions are often difficult to discharge at implementation time. Even well-understood algorithms, like line-sweep for polygon union [PS85], present much trouble. Why? Such algorithms obtain good combinatorial complexity bounds by exploiting geometric orders on the input. These relations are often implicit, so an algorithm can only probe them pointwise with a collection of predicate functions answering, e.g., “Is point p left of edge e?”. In implementations, the reply must depend on arithmetic with finitely represented numbers. The trouble originates here.

In school development problem, determining location is one of important things to consider. In this research, the purpose is to determine the location of SMAN 9 Denpasar if it will be built. One of algorithms in computational geometry that can be used to find solution of facility location problem is multiplicatively weighted Voronoi diagram in two dimensions. The result of weighted Voronoi diagram shows the influence of each site to the surrounding area. Then, the location of SMAN 9 Denpasar is obtained by determining the center of the largest empty circle of the weighted Voronoi diagram.

Algorithms in computational geometry are of increasing importance in computer-aided design, for example, in the layout of integrated circuits. The efficient computation of the intersection of several superimposed figures is a basic problem. Plane figures defined by points connected by straight line segments are considered, for example, polygons (not necessarily simple) and maps (embedded planar graphs). The regions into which the plane is partitioned by these intersecting figures are to be processed in various ways such as listing the boundary of each region in cyclic order or sweeping the interior of each region. Let m be the total number of points of all the figures involved and s be the total number of intersections of all line segments. A two plane-sweep algorithm that solves the problems above is presented; in the general case (non convexity) in time O((n+s)log-n) and space O(n+s); when the regions of each given figure are convex, the same can be achieved in time O(n log n +s) and space O(n)

This work presents an adapted version of the Computational Geometry Algorithm (CGA) used for the development of audio-based applications and services. The CGA algorithm analyses an audio stream and produces a unique set of points that can be considered to be the audio data “fingerprint”. It is shown that this fingerprint is coding-independent, a fact that can render the proposed algorithm suitable for multiple purposes, including the categorisation of content identity and the identification of audio clips, hence providing support for the realisation of audio sorting/searching tasks and services. Additionally, based on specific novel applications and services, the overall algorithmic performance and efficiency characteristics of the CGA algorithm are discussed and analysed.

Enhancements to array processors in the form of broadcast buses have been proposed for improving the speeds of algorithms in linear algebra, image processing and computational geometry. In this paper, we consider certain practical issues in such arrays which include fewer processors connected to the broadcast buses and finite time, namely log N time for broadcasting data to N processors. We propose a modified broadcast bus VLSI architecture which consists of a √N × √N mesh connected structure and a hierarchy of broadcast buses in each row and in each column such that every bus has k PE's. That is, in any row or column, in the first level there are \(\frac{{\sqrt N }}{k}\)buses with groups of k PE's connected to each bus. One PE from each of this group is connected to second level of buses in a similar manner. This is recursively done until there are only k PE's left which are connected by a broadcast bus. With this architecture, maximum, minimum, or sum of N values can be found in O(log N), median row of a binary picture in O(log N), shortest distance between two points in O(log N). This architecture is well suited for parallel processing of applications in Linear Algebra, Image Processing, Computational Geometry and Numerical Computations. These restricted connections to buses reduces the I/O ports significantly, and therefore, is more suitable for VLSI implementation.

Pawlak recently introduced rough set flow graphs (RSFGs) as a graphical framework for reasoning from data. No study, however, has yet investigated the complexity of the accompanying inference algorithm, nor the complexity of inference in RSFGs. In this paper, we show that the traditional RSFG inference algorithm has exponential time complexity. We then propose a new RSFG inference algorithm that exploits the factorization in a RSFG. We prove its correctness and establish its polynomial time complexity. In addition, we show that our inference algorithm never does more work than the traditional algorithm. Our discussion also reveals that, unlike traditional rough set research, RSFGs make implicit independency assumptions regarding the problem domain.KeywordsReasoning under uncertaintyrough set flow graphs

Let R and B be two sets of points such that the points of R are colored red and the points of B are colored blue. Let P be a path such that |R| vertices of P are red and |B| vertices of P are blue. We study the problem of computing a crossing-free drawing of P such that each blue vertex is represented as a point of B and each red vertex of P is represented as a point of R. We show that such a drawing can always be realized by using at most one bend per edge.

Expected size of random Tukey layers and convex layers