A Fast Efficient Parallel Hough Transform Algorithm on LARPBS

A parallel algorithm for Hough transform on a linear array with reconfigurable pipeline bus system (LARPBS) is presented. Suppose the number of -values to be considered is m, for an image with n × n pixels, the algorithm can complete Hough transform in O(1) time using mn ² processors and achieve optimal speed and efficiency. We also illustrate how to partition data and perform the algorithm on a LARPBS with fewer than mn ² processors, and hence show that the algorithm is highly scalable.     

Parallel sample path generation for discrete event systems and the traffic smoothing problem

We review two approaches, the Standard Clock (SC) technique and Augmented System Analysis (ASA), that have been proposed for generating sample paths of Discrete Event Systems (DES) in parallel. These are placed in the unifying framework of the fundamentalsample path constructability problem: for a finite discrete parameter set = {₁, ..., _m }given a sample path under ₁ the problem is to simultaneously construct sample paths under all remaining parameter values. Using the ASA approach we then consider the problem of smoothing arbitrary, generally bursty, and possibly nonstationary traffic processes which are encountered in many applications, especially in the area of flow control for integrated-service, high-speed networks. We derive some basic structural properties of a smoothing scheme known as the Leaky Bucket (LB) mechanism through which it is seen that the variability of a traffic process can be monotonically decreased by decreasing an integer-valued parameter of this scheme. Finally, we show that a sample path under any value of this parameter is constructable with respect to an observed sample path under any other value. Therefore, by controlling this parameter on line, we show how simple iterative optimization schemes can be used to achieve typical design objectives such as keeping both the mean packet delay due to smoothing and the variability of the traffic process low.     

Optimal algorithms for symmetry detection in two and three dimensions

Exact algorithms for detecting all rotational and involutional symmetries in point sets, polygons and polyhedra are described. The time complexities of the algorithms are shown to be (n) for polygons and (n logn) for two- and three-dimensional point sets. (n logn) time is also required for general polyhedra, but for polyhedra with connected, planar surface graphs (n) time can be achieved. All algorithms are optimal in time complexity, within constants.     

A Note on Scheduling Tall/Small Multiprocessor Tasks with Unit Processing Time to Minimize Maximum Tardiness

We study the scheduling situation where n tasks, subjected to release dates and due dates, have to be scheduled on m parallel processors. We show that, when tasks have unit processing times and either require 1 or m processors simultaneously, the minimum maximal tardiness can be computed in polynomial time. Two algorithms are described. The first one is based on a linear programming formulation of the problem while the second one is a combinatorial algorithm. The complexity status of this tall/small task scheduling problem P|r _i ,p _i =1, size _i {1,m}|T _max was unknown before, even for two processors.     

Functional Estimation with Respect to a Threshold Parameter via Dynamic Split-and-Merge

We consider a class of stochastic models for which the performance measure is defined as a mathematical expectation that depends on a parameter , say (), and we are interested in constructing estimators of in functional form (i.e., entire functions of ), which can be computed from a single simulation experiment. We focus on the case where is a continuous parameter, and also consider estimation of the derivative (). One approach for doing that, when is a parameter of the probability law that governs the system, is based on the use of likelihood ratios and score functions. In this paper, we study a different approach, called split-and-merge, for the case where is a threshold parameter. This approach can be viewed as a practical way of running parallel simulations at an infinite number of values of , with common random numbers. We give several examples showing how different kinds of parameters such as the arrival rate in a queue, the probability that an arriving customer be of a given type, a scale parameter of a service time distribution, and so on, can be turned into threshold parameters. We also discuss implementation issues.     

Visibility,occlusion, and the aspect graph

This chapter studies the ways in which the topology of the image of a polyhedron changes with changing viewpoint. We catalog the ways that the topological appearance, or aspect, can change. This enables us to find maximal regions of viewpoints of the same aspect. We use these techniques to construct the viewpoint space partition (VSP), a partition of viewpoint space into maximal regions of constant aspect, and its dual, the aspect graph. Here, we present tight bounds on the maximum size of the VSP and the aspect graph and give algorithms for their construction, first in the convex case and then in the general case. In particular, we give bounds on the maximum size of (n ²) and (n ⁶) under an orthographic projection viewing model and of (n ³) and (n ⁹) under a perspective viewing model. The algorithms make use of a new representation of the appearance of polyhedra from all viewpoints, called the aspect representation or asp. We believe that this representation is one of the significant contributions of this paper.This work was supported in part by the NSF under grants DCR-8520870 and IRI-8802436.     

Pushing Convertible Constraints in Frequent Itemset Mining

Recent work has highlighted the importance of the constraint-based mining paradigm in the context of frequent itemsets, associations, correlations, sequential patterns, and many other interesting patterns in large databases. Constraint pushing techniques have been developed for mining frequent patterns and associations with antimonotonic, monotonic, and succinct constraints. In this paper, we study constraints which cannot be handled with existing theory and techniques in frequent pattern mining. For example, avg(S)v, median(S)v, sum(S)v (S can contain items of arbitrary values, {<, <, , } and v is a real number.) are customarily regarded as tough constraints in that they cannot be pushed inside an algorithm such as Apriori. We develop a notion of convertible constraints and systematically analyze, classify, and characterize this class. We also develop techniques which enable them to be readily pushed deep inside the recently developed FP-growth algorithm for frequent itemset mining. Results from our detailed experiments show the effectiveness of the techniques developed.     

An optimal parallel algorithm for triangulating a set of points in the plane

This paper presents an optimal parallel algorithm for triangulating an arbitrary set ofn points in the plane. The algorithm runs inO(logn) time usingO(n) space andO(_n) processors on a Concurrent-Read, Exclusive-Write Parallel RAM model (CREW PRAM). The parallel lower bound on triangulation is (logn) time so the best possible linear speedup has been achieved. A parallel divide-and-conquer technique of subdividing a problem into subproblems is employed.     

A Delay-Averaged Logistic Model

For the equation x(t) = x(t) (1-(1/) _t-- ^t- x(u)du), > 0, > 0, > 0, conditions for the stability of a nonzero stationary solution under small perturbations are determined.     

An optimal time bound for oblivious routing

The problem of routing data packets in a constant-degree network is considered. A routing scheme is calledoblivious if the route taken by each packet is uniquely determined by its source and destination. The time required for the oblivious routing ofn packets onn processors is known to be (n). It is demonstrated that the presence of extra processors can expedite oblivious routing. More specifically, the time required for the oblivious routing ofn packets onp processors is (n/p + logn).     

Pipelined search on coarse grained networks

The time complexity of searching a sorted list ofn elements in parallel on a coarse grained network of diameterD and consisting ofN processors (wheren may be much larger thanN) is studied. The worst case period and latency of a sequence of pipeline search operation are easity seen to be (logn–logN) and (D+logn–logN), respectively. Since forn=N ¹⁺⁽¹⁾ the worst-case period is (logn) (which can be achieved by a single processor), coarse-grained networks appear to be unsuitable for the search problem. By contrast, it is demonstrated using standard queuing theory techniques that a constant expected period can be achieved provided thatn=O(N2 ^N ).This research was supported by the Natural Sciences and Engineering Research Council of Canada under Grants A3336 and A9173.     

Design and analysis of delay-insensitive modulo-N counters

Various delay-insensitive circuits for modulo-N counters are formally derived and analyzed. Modulo-N counters are used in many circuit designs and have a simple specification, but allow for a surprising variety of decompositions into networks of basic components. We present three decompositions in detail. Along the way we explai our correctness criteria and show to analyze the area complexity and response time of each decomposition. Our final decomposition for the modulo-N counter has optimal area complexity of (logN) and optimal response time of (1).     

Layup optimization against buckling of shear panels

The object of the study was to optimize the shear buckling load of laminated composite plates. The laminates lacked coupling between bending and extension (B _ij=0) but had otherwise arbitrary selection of the ply angle variation through the thickness. The plates were rectangular and either simply supported or clamped on all edges. For orthotropic plates, it was seen that there is only one parameter necessary for finding the optimal design for different materials and plate aspect ratios. This parameter can be interpreted as the layup angle in a (+/–) orthotropic laminate. When bendingtwisting coupling is present, the buckling strength depends on the direction of the applied load. A laminate with non-zero bending-twisting coupling stiffnesses can be described with four lamination parameters. The allowable region of these parameters was investigated, and an optimization of the buckling load within this region was performed. It was seen that even this is a one parameter problem. This parameter can be interpreted as the layup anlge in an off-axis unidirectional laminate ().Notations A _ij in-plane stiffnesses of anisotropic plates, Tsai and Hahn (1980) - B _ij coupling stiffnesses of anisotropic plates - D _ij bending stiffnesses of anisotropic plates - D _ij ^* normalized bending stiffnesses - a, b, h length, width and thickness of the plate - x, y in-plane coordinates - z through-the-thickness coordinate - z ^* normalized through-the-thickness coordinate - w (x, y) out-of-plane deformation - N _xy shear buckling load - W ₁ ^* toW ₄ ^* lamination parameters - U ₁ toU ₅ linear combinations of the on-axis moduli - (z) layup angle - f _k functional of(z)     

An Estimation Problem for Quasilinear Stochastic Partial Differential Equations

A problem of estimating a functional parameter (x) and functionals () based on observation of a solution u (t, x) of the stochastic partial differential equation is considered. The asymptotic problem setting, as the noise intensity 0, is investigated.     

Finding extrema with unary predicates

We consider the problem of determining the maximum and minimum elements of a setX={x₁...,x _n }, drawn from some finite universeU of real numbers, using only unary predicates of the inputs. It is shown that (n+ log¦U¦) unary predicate evaluations are necessary and sufficient, in the worst case. Results are applied to (i) the problem of determining approximate extrema of a set of real numbers, in the same model, and (ii) the multiparty broadcast communication complexity of determining the extrema of an arbitrary set of numbers held by distinct processors.     

Packings in two dimensions: Asymptotic average-case analysis of algorithms

New approximation algorithms for packing rectangles into a semi-infinite strip are introduced in this paper. Within a standard probability model, an asymptotic average-case analysis is given for the wasted space in the packings produced by these algorithms.An off-line algorithm is presented along with a proof that it wastes (/n)space on the average, wheren is the number of rectangles packed. This result is known to apply to optimal packings as well. Several on-line shelf algorithms are also analyzed. Withn assumed known in advance, one such algorithm is described and shown to waste (n ^2/3) space on the average. It is proved that this result also characterizes optimal on-line shelf packings. For a very general class of linear-time algorithms, it is shown that a constant (nonzero) fraction of the space must be wasted on the average for alln, and a lower bound on this fraction in terms of algorithm parameters is given. Finally, the paper discusses the implications of the above results for dynamic packing and two-dimensional bin-packing problems.     

Fast Theta-Subsumption with Constraint Satisfaction Algorithms

Relational learning and Inductive Logic Programming (ILP) commonly use as covering test the -subsumption test defined by Plotkin. Based on a reformulation of -subsumption as a binary constraint satisfaction problem, this paper describes a novel -subsumption algorithm named Django,¹ which combines well-known CSP procedures and -subsumption-specific data structures. Django is validated using the stochastic complexity framework developed in CSPs, and imported in ILP by Giordana et Saitta. Principled and extensive experiments within this framework show that Django improves on earlier -subsumption algorithms by several orders of magnitude, and that different procedures are better at different regions of the stochastic complexity landscape. These experiments allow for building a control layer over Django, termed Meta-Django, which determines the best procedures to use depending on the order parameters of the -subsumption problem instance. The performance gains and good scalability of Django and Meta-Django are finally demonstrated on a real-world ILP task (emulating the search for frequent clauses in the mutagenesis domain) though the smaller size of the problems results in smaller gain factors (ranging from 2.5 to 30).     

An improved parallel algorithm for integer GCD

We present a simple parallel algorithm for computing the greatest common divisor (gcd) of twon-bit integers in the Common version of the CRCW model of computation. The run-time of the algorithm in terms of bit operations isO(n/logn), usingn ¹⁺ processors, where is any positive constant. This improves on the algorithm of Kannan, Miller, and Rudolph, the only sublinear algorithm known previously, both in run time and in number of processors; they requireO(n log logn/logn),n ² log² n, respectively, in the same CRCW model.We give an alternative implementation of our algorithm in the CREW model. Its run-time isO(n log logn/logn), usingn ¹⁺ processors. Both implementations can be modified to yield the extended gcd, within the same complexity bounds.Supported in part by an IBM Graduate Fellowship and a Bantrell Postdoctoral Fellowship.Supported in part by a Weizmann Postdoctoral Fellowship.4 All logarithms are to base 2.     

Representations of numbers and finite automata

Numeration systems, the basis of which is defined by a linear recurrence with integer coefficients, are considered. We give conditions on the recurrence under which the function of normalization which transforms any representation of an integer into the normal one—obtained by the usual algorithm—can be realized by a finite automaton. Addition is a particular case of normalization. The same questions are discussed for the representation of real numbers in basis , where is a real number > 1, in connection with symbolic dynamics. In particular it is shown that if is a Pisot number, then the normalization and the addition in basis are computable by a finite automaton.This work has been supported by the PRC Mathématiques et Informatique.     

Parallel solution of recurrences on a tree machine

The recurrencex _o =a _o x _i =a _i+b _i x _i–1,i = 1, 2,...,n–1 requiresO(n) operations on a sequential computer. Elegant parallel solutions exist, however, that reduce the complexity toO(logN) usingNn processors. This paper discusses one such solution, designed for a tree-structured network of processors.A tree structure is ideal for solving recurrences. It takes exactly one sweep up and down the tree to solve any of several classes of recurrences, thus guaranteeing a solution inO(logN) time for a tree withNn leaf nodes. Ifn exceedsN, the algorithm efficiently pipelines the operation and solves the recurrence inO(n/N + logN) time.