CALCULATING RECURRENCES USING THE BIRD-MEERTENS FORMALISM

1995 ◽  
Vol 05 (02) ◽  
pp. 179-190 ◽  
Author(s):  
WENTONG CAI ◽  
DAVID B. SKILLICORN
Keyword(s):  
Software Development ◽  
Parallel Algorithms ◽  
Time Complexity ◽  
Large Range ◽  
Parallel Solution ◽  
Parallel Time

The Bird-Meetens formalism is an approach to software development and computation based on datatype theories. In this paper we build new operators for the theory of lists that compute generalized recurrences and show that they have logarithmic parallel time complexity. As many applications can be cast as forms of recurrences, this allows a large range of parallel algorithms to be derived within the Bird-Meertens formalism. We illustrate by deriving a parallel solution to the maximum segment sum problem.

scholarly journals SEQUENTIAL AND PARALLEL ALGORITHMS FOR THE k CLOSEST PAIRS PROBLEM

1995 ◽  
Vol 05 (03) ◽  
pp. 273-288 ◽  
Author(s):  
HANS-PETER LENHOF ◽  
MICHIEL SMID
Keyword(s):  
Decision Tree ◽  
Parallel Algorithms ◽  
Dimensional Space ◽  
Decision Tree Model ◽  
Sequential Algorithm ◽  
Tree Model ◽  
Parallel Time ◽  
Parallel Version ◽  
Pram Model ◽  
Crcw Pram

Let S be a set of n points in D-dimensional space, where D is a constant, and let k be an integer between 1 and [Formula: see text]. A new and simpler proof is given of Salowe’s theorem, i.e., a sequential algorithm is given that computes the k closest pairs in the set S in O(n log n+k) time, using O(n+k) space. The algorithm fits in the algebraic decision tree model and is, therefore, optimal. Salowe’s algorithm seems difficult to parallelize. A parallel version of our algorithm is given for the CRCW-PRAM model. This version runs in O((log n)2 log log n) expected parallel time and has an O(n log n log log n+k) time-processor product. Finally, actual running times are given of an implementation of our sequential algorithm.

AN IMPROVED PARALLEL PREFIX ALGORITHM ON OTIS-MESH

2006 ◽  
Vol 16 (04) ◽  
pp. 429-440 ◽  
Author(s):  
PRASANTA K. JANA ◽  
BHABANI P. SINHA
Keyword(s):  
Parallel Algorithms ◽  
Parallel Algorithm ◽  
Time Complexity ◽  
Data Distribution ◽  
General Theme ◽  
Parallel Prefix

Wang and Sahni [4] reported two parallel algorithms for N-point prefix computation on an N-processor OTIS-Mesh optoelectronic computer. The overall time complexity for both SIMS and MIMD models of their first algorithm was shown to be (8 N1/4 - 1) electronic moves and 2 OTIS moves. This was further reduced to (7 N1/4 - 1) electronic moves and 2 OTIS moves in their second algorithm. We present here an improved parallel algorithm for N-point prefix computation on an N-processor OTIS-Mesh, which needs (5.5 N1/4 + 3) electronic moves and 2 OTIS moves. Our algorithm is based on the general theme of parallel prefix algorithm proposed in [4] but following the data distribution and local prefix computation similar to that of [1].

Distributed Operational Space Formulation of Serial Manipulators

2013 ◽  
Vol 9 (2) ◽  
Author(s):  
Kishor D. Bhalerao ◽  
James Critchley ◽  
Denny Oetomo ◽  
Roy Featherstone ◽  
Oussama Khatib
Keyword(s):  
Parallel Algorithms ◽  
Time Complexity ◽  
Degrees Of Freedom ◽  
Null Space ◽  
Divide And Conquer ◽  
Serial Manipulators ◽  
Divide And Conquer Algorithm ◽  
Operational Space ◽  
Space Formulation ◽  
Space Dynamics

This paper presents a new parallel algorithm for the operational space dynamics of unconstrained serial manipulators, which outperforms contemporary sequential and parallel algorithms in the presence of two or more processors. The method employs a hybrid divide and conquer algorithm (DCA) multibody methodology which brings together the best features of the DCA and fast sequential techniques. The method achieves a logarithmic time complexity (O(log(n)) in the number of degrees of freedom (n) for computing the operational space inertia (Λe) of a serial manipulator in presence of O(n) processors. The paper also addresses the efficient sequential and parallel computation of the dynamically consistent generalized inverse (J¯e) of the task Jacobian, the associated null space projection matrix (Ne), and the joint actuator forces (τnull) which only affect the manipulator posture. The sequential algorithms for computing J¯e, Ne, and τnull are of O(n), O(n2), and O(n) computational complexity, respectively, while the corresponding parallel algorithms are of O(log(n)), O(n), and O(log(n)) time complexity in the presence of O(n) processors.

SOLVING DISCRETE-TIME LYAPUNOV EQUATIONS FOR THE CHOLESKY FACTOR ON A SHARED MEMORY MULTIPROCESSOR

1996 ◽  
Vol 06 (03) ◽  
pp. 365-376 ◽  
Author(s):  
JOSE M. CLAVER ◽  
VICENTE HERNANDEZ ◽  
ENRIQUE S. QUINTANA
Keyword(s):  
Parallel Algorithms ◽  
Shared Memory ◽  
Discrete Time ◽  
Lyapunov Equation ◽  
Lyapunov Equations ◽  
Parallel Solution ◽  
Cholesky Factor ◽  
Large Order ◽  
Shared Memory Multiprocessor

In this paper we study the parallel solution of the discrete-time Lyapunov equation. Two parallel fine and medium grain algorithms for solving dense and large order equations [Formula: see text] on a shared memory multiprocessor are presented. They are based on Hammarling’s method and directly obtain the Cholesky factor of the solution. The parallel algorithms work following an antidiagonal wavefront. In order to improve the performance, column-block-oriented and wrap-around algorithms are used. Finally, combined fine and medium grain parallel algorithms are presented.

RANDOMIZED PARALLEL ALGORITHMS FOR TRAPEZOIDAL DIAGRAMS

1992 ◽  
Vol 02 (02) ◽  
pp. 117-133 ◽  
Author(s):  
KENNETH L. CLARKSON ◽  
RICHARD COLE ◽  
ROBERT E. TARJAN
Keyword(s):  
Parallel Algorithms ◽  
Line Segments ◽  
Expected Time ◽  
Parallel Time ◽  
Simpler Algorithm ◽  
Simple Chain ◽  
Time Bounds ◽  
Serial Algorithm ◽  
Crcw Pram

We describe randomized parallel algorithms for building trapezoidal diagrams of line segments in the plane. The algorithms are designed for a CRCW PRAM. For general segments, we give an algorithm requiring optimal O(A+n log n) expected work and optimal O( log n) time, where A is the number of intersecting pairs of segments. If the segments form a simple chain, we give an algorithm requiring optimal O(n) expected work and O( log n log log n log * n) expected time , and a simpler algorithm requiring O(n log * n) expected work. The serial algorithm corresponding to the latter is among the simplest known algorithms requiring O(n log * n) expected operations. For a set of segments forming K chains, we give an algorithm requiring O(A+n log * n+K log n) expected work and O( log n log log n log * n) expected time. The parallel time bounds require the assumption that enough processors are available, with processor allocations every log n steps.

Fast Sequential and Parallel Vertex Relabelings of Km,m

2015 ◽  
Vol 26 (01) ◽  
pp. 33-50 ◽  
Author(s):  
Sanpawat Kantabutra
Keyword(s):  
Time Complexity ◽  
Simple Graph ◽  
Open Problems ◽  
Parallel Time ◽  
Erew Pram ◽  
Arbitrary Graphs

Given an undirected, connected, simple graph G = (V,E), two vertex labelings LV and L'V of the vertices of G, and a label flip operation that interchanges a pair of labels on adjacent vertices, the Vertex Relabeling Problem is to transform G from LV into L'V using the flip operation. Agnarsson et al. showed solving the Vertex Relabeling Problem on arbitrary graphs can be done in θ(n2), where n is the number of vertices in G. In this article we study the Vertex Relabeling Problem on graphs Km,m and introduce the concept of parity and precise labelings. We show that, when we consider the parity labeling, the problem on graphs Km,m can be solved quickly in O(log m) time using m processors on an EREW PRAM. Additionally, we also show that the number of processors can be further reduced to [Formula: see text] in this case while the time complexity does not change. When the labeling is precise, the parallel time complexity increases by a factor of log m while the processor complexities remain m and [Formula: see text]. We also show that, when graphs are restricted to Km,m, this problem can be solved optimally in O(m) time when the labeling is parity, and can be solved in O(m log m) time when the labeling is precise, thereby improving the result in Agnarsson et al. for this specific case. Moreover, we generalize the result in the case of precise labeling to the cases when LV and L'V can be any configuration. In the end we give a conclusion and a list of some interesting open problems.

scholarly journals Automata Technique for The LCS Problem

2019 ◽  
Vol 35 (1) ◽  
pp. 21-37
Author(s):  
Trường Huy Nguyễn
Keyword(s):  
Dynamic Programming ◽  
Parallel Algorithms ◽  
Time Complexity ◽  
Dynamic Programming Algorithm ◽  
Longest Common Subsequence ◽  
Programming Algorithm ◽  
Worst Case ◽  
Common Subsequence ◽  
Input Strings ◽  
Upper Estimate

In this paper, we introduce two efficient algorithms in practice for computing the length of a longest common subsequence of two strings, using automata technique, in sequential and parallel ways. For two input strings of lengths m and n with m ≤ n, the parallel algorithm uses k processors (k ≤ m) and costs time complexity O(n) in the worst case, where k is an upper estimate of the length of a longest common subsequence of the two strings. These results are based on the Knapsack Shaking approach proposed by P. T. Huy et al. in 2002. Experimental results show that for the alphabet of size 256, our sequential and parallel algorithms are about 65.85 and 3.41m times faster than the standard dynamic programming algorithm proposed by Wagner and Fisher in 1974, respectively.

ON PARALLEL RECOGNITION OF TWO CLASSES OF 2-D ARRAY PATTERNS

1992 ◽  
Vol 06 (02n03) ◽  
pp. 293-299
Author(s):  
WOJCIECH RYTTER ◽  
AHMED SAOUDI
Keyword(s):  
Parallel Algorithms ◽  
Time Complexity ◽  
Regular Array ◽  
Parallel Complexity ◽  
Context Free

We investigate the parallel complexity of recognition problems for context-free and regular array (image) sets. We show that the sequential time complexity of the recognition of an n × n image is O(n5). The space required for these recognition problems is O(n5). We prove that there are log 2n time parallel algorithms with BM (n4) and n2 BM (n) processors for the recognition of context-free and regular array sets, respectively, where BM (n) is the number of processors sufficient to multiply two boolean n × n matrices in logarithmic time. We develop also a methodology for processing images using composition systems.

Sign in / Sign up

Export Citation Format

Share Document