Fast Parallel Algorithm Research Articles

A fast cost-optimal parallel algorithm for the lowest common ancestor problem

The problem of computing the lowest common ancestors of all pairs of nodes in a rooted tree is central in a large number of practical applications. The purpose of this note is to propose a very simple cost-optimal parallel algorithm to solve the lowest common ancestor problem. More precisely, with an n-node rooted tree as input, our algorithm runs in O(log n) time using O( n 2 lopg n) processors on the EREW-PRAM model.

Comparative evaluation of fast thinning algorithms on a multiprocessor architecture

Abstract A comparative evaluation of some fast parallel thinning algorithms for elongated shapes on an overlapped shared memory multiprocessor architecture (OSMMA) is presented. The evaluation is based on the execution time and multiprocessor speed-up of the algorithms, as well as the quality of the skeletonized image structures. Issues relating to efficient algorithm implementation on the distributed memory architecture and refinements in the algorithms for better results are also discussed. The algorithms implemented include our own thinning technique based on the concept of object edges width compression that achieves efficient results while significantly decreasing execution timings. Experimental results for some real images are presented.

Knapsack packing networks

A knapsack packing neural network of 4n units with both low-order and conjunctive asymmetric synapses is derived from a non-Hamiltonian energy function. Parallel simulations of randomly generated problems of size n in {5, 10, 20} are used to compare network solutions with those of simple greedy fast parallel enumerative algorithms.

Fast parallel algorithms for the Maximum Empty Rectangle problem

We present efficient parallel algorithms for the maximum empty rectangle problem in this paper. On crew pram, we solve the area version of this problem inO(log 2 n) time usingO(nlogn) processors. The perimeter version of this problem is solved inO(logn) time usingO(nlog 2 n) processors. On erew pram, we solve both the problems inO(logn) time usingO(n 2/logn) processors. We also present anO(logn) time algorithm on a mesh-of-trees architecture.

Using Interior-Point Methods for Fast Parallel Algorithms for Bipartite Matching and Related Problems

In this paper interior-point methods for linear programming, developed in the context of sequential computation, are used to obtain a parallel algorithm for the bipartite matching problem. This algorithm finds a maximum cardinality matching in a bipartite graph with n nodes and m edges in $O(\sqrt m \log ^3 n)$ time on a CRCW PRAM. The results here extend to the weighted bipartite matching problem and to the zero-one minimum-cost flow problem, yielding $O(\sqrt m \log ^2 n\log nC)$ algorithms, where $C > 1$ is an upper bound on the absolute value of the integral weights or costs in the two problems, respectively. The results here improve previous bounds on these problems and introduce interior-point methods to the context of parallel algorithm design.

A fast parallel algorithm for the solution of tridiagonal linear systems

We present a parallel algorithm for the solution of tridiagonal linear systems based on the method of partitioning and backward elimination. A given N × N system is partitioned into r blocks each of size n × n (N = rn n even). Within each block the system is rewritten by collecting pairs of equations from the top and bottom (written backwards); this makes it suitable to solve the subsystem by a UL-factorization of its coefficient matrix. Once a core system of size 2r × 2r has been solved, solutions of the r subsystems can be computed in parallel. Interestingly, the serial arithmetical operations count for the present algorithm is 0(1612;N); this makes it faster than the quadrant interlocking factorization method of Chawla and Passi [1], the partitioning method of Wang [7] and cyclic reduction (see Hockney and Jesshope [6, p. 479]), each of which has a serial count of 0(17N).

Modelling a fast parallel thinning algorithm for shared memory SIMD computers

We present the mapping of a parallel thinning algorithm on shared memory SIMD computers. Four models of SM SIMD computers are considered. The parallel thinning algorithm is presented for all these four models of computers. The algorithm has been analyzed for time and cost performance on four models of SM SIMD computers. It has been shown that the CREW/CRCW SM SIMD thinning algorithm is cost optimal under a certain condition. A different condition makes the algorithm cost optimal on EREW/ERCW SM SIMD computers.

Fast parallel simulated annealing for traveling salesman problem on SIMD machines with linear interconnections

In this paper, we present a fast parallel simulated annealing algorithm for solving traveling salesman problem(TSP) on SIMD machines with linear interconnections among processing elements. Simulated annealing is a generally applicable algorithm for solving combinatorial optimization problems by generating a sequence of moves at decending values of a control parameter. In our algorithm for TSP, the move operation can be executed in proportional to the time taken to broadcast a bit in one processing element (PE) to all the other PE's. Therefore, if a control unit has the broadcasting capability as is often the case with the SIMD machine, the move operation can be done in constant time and the whole simulated annealing algorithm has the time complexity only proportional to the number of the moves.

Approximate algorithms for the knapsack problem on parallel computers

Computing an optimal solution to the knapsack problem is known to be NP-hard. Consequently, fast parallel algorithms for finding such a solution without using an exponential number of processors appear unlikely. An attractive alternative is to compute an approximate solution to this problem rapidly using a polynomial number of processors. In this paper, we present an efficient parallel algorithm for finding approximate solutions to the 0–1 knapsack problem. Our algorithm takes an ε, 0 < ε < 1, as a parameter and computes a solution such that the ratio of its deviation from the optimal solution is at most a fraction ε of the optimal solution. For a problem instance having n items, this computation uses O(n 5 2 /ε 3 2 ) processors and requires O( log 3 n + log 2 n log ( 1 ε )) time. The upper bound on the processor requirement of our algorithm is established by reducing it to a problem on weighted bipartite graphs. This processor complexity is a significant improvement over that of other known parallel algorithms for this problem.

A fast parallel form IIR adaptive filter algorithm

In real-time digital signal processing, a significant amount of computational effort can be saved if the input signals are represented in terms of a set of orthogonal signal components. This is because the representation admits processing schemes in which each of these orthogonal signal components can be independently processed. On this basis, a new infinite impulse response (IIR) adaptive filter algorithm which extends Shynk's work (1989) is proposed. In it the discrete cosine transform is used to split the input signal into a set of approximately orthogonal signal components. Subsequently, these orthogonal signal components are filtered by a bank of IIR adaptive filters whose coefficients are independently updated to minimize a common error. Computer simulations to demonstrate the performance of the proposed algorithm are presented.< <ETX xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">&gt;</ETX>

Fast Parallel Algorithms for Multivariable Polynomial

Fast Parallel Algorithms for Multivariable Polynomial

New fast parallel algorithm for the connected component problem and its VLSI implementation

We present an O(log n) compare-exchange time parallel algorithm to compute the connected components of a given graph. We also introduce a simple regular VLSI architecture on which the proposed algorithm can readily be implemented requiring n3 identical processing elements and O(n) communication time, where n is the number of vertices in the graph.

A fast parallel algorithm to recognize partitionable graphs

We define a class of graphs which generalizes the well-known class of cographs or complement-reducible graphs and show that the graphs in our class can be recognized fast in parallel. More precisely, with an arbitrary graph G with n vertices and m edges as input, the proposed recognition algorithm runs in O(log n) time using O(( n 2/log n)+ mn) processors on an EREW parallel random access machine.

String matching with weighted errors

In the approximate string matching problem, differences are allowed between the pattern string P and each of its occurrences in the text string T, and one is interested in finding all the occurrences of P in T with at most k differences. We consider here weighted differences (errors) between P and T and develop fast sequential and parallel algorithms. In particular, we allow the following types of errors: mismatch whose weight depends on the mismatching characters, extra character with constant weight, missing character with constant weight, and transposition of two consecutive characters with constant weight. A set of theoretical results allows to extend known algorithms to solve this problem with O( kn) sequential time and O( k + log m) parallel time on a 4PRAM model with max{ n + k + 1, m p2} processors, where k is the maximum sum of the error weights, n is the length of T, and m is the length of P.

Parallel algorithms for matrix normal forms

Here we offer a new randomized parallel algorithm that determines the Smith normal form of a matrix with entries being univariate polynomials with coefficients in an arbitrary field. The algorithm has two important advantages over our previous one: the multipliers relating the Smith form to the input matrix are computed, and the algorithm is probabilistic of Las Vegas type, i.e., always finds the correct answer. The Smith form algorithm is also a good sequential algorithm. Our algorithm reduces the problem of Smith form computation to two Hermite form computations. Thus the Smith form problem has complexity asymptotically that of the Hermite form problem. We also construct fast parallel algorithms for Jordan normal form and testing similarity of matrices. Both the similarity and non-similarity problems are in the complexity class RNC for the usual coefficient fields, i.e., they can be probabilistically decided in polylogarithmic time using polynomially many processors.

A parallel algorithm for solving sparse triangular systems

A fast parallel algorithm, which is generalized from the parallel algorithms for solving banded linear systems, is proposed to solve sparse triangular systems. The original problem is transformed into a directed graph. The solving procedure then consists of eliminating edges in this graph. The worst-case time-complexity of this parallel algorithm is O(log/sup 2/n) where n is the size of the coefficient matrix. When the coefficient matrix is a triangular banded matrix with bandwidth m, then the time-complexity of the algorithm is O(log(m)*log(n)). >

Fast sequential and parallel algorithms for finding the largest rectangle separating two sets

Given a bounding isothetic rectangle BR and two sets of points A and B with cardinalities n and m inside it, we have to find an isothetic rectangle containing maximum number of points from set A and no point from set B. We consider two limiting cases of this problem when the cardinalities of set A (resp. set B) is much greater than that of set B (resp. set ,A). We present efficient sequential and parallel algorithms for these two problems. Our sequential algorithms run in O((n + m)log m + m 2) and O((m+ n) log n + n 2) time respectively. The parallel algorithms in CREW PRAM run in o(log n) ando(log m 2) time using O(max(n,m 2/logm)) and O(max(m,n 2/logn)) processors respectively. Our sequential algorithms are faster than a previous algorithm under these constraints on cardinality. No previous parallel algorithm was known for this problem. We also present an optimal systolic algorithm for the original problem.

A fast parallel algorithm for blind estimation of noise variance

A blind noise variance algorithm that recovers the variance of noise in two steps is proposed. The sample variances are computed for square cells tessellating the noise image. Several tessellations are applied with the size of the cells increasing fourfold for consecutive tessellations. The four smallest sample variance values are retained for each tessellation and combined through an outlier analysis into one estimate. The different tessellations thus yield a variance estimate sequence. The value of the noise variance is determined from this variance estimate sequence. The blind noise variance algorithm is applied to 500 noisy 256*256 images. In 98% of the cases, the relative estimation error was less than 0.2 with an average error of 0.06. Application of the algorithm to differently sized images is also discussed.< <ETX xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">&gt;</ETX>

Parallelism and fast solution of linear systems

We review some of the most important resulsts in the area of fast parallel algorithms for the solution of linear systems and related problems, such as matrix inversion, computation of the determinant and of the adjoint matrix. We analyze both direct and iterative methods implemented in various models of parallel computation.

Parallel rational interpolation

A fast parallel algorithm for rational interpolation based on orthogonal polynomials, which is suitable for both shared-memory and message-passing multiprocessor systems is proposed. In the shared-memory case with N + 1 identical processors, the algorithm requires 0(N log N) parallel arithmetic steps to construct all rational interpolants at once, where N +1 is the number of data points. Extensions to message-passing multiprocessor systems such as the hypercube are also discussed. The hypercube version of the algorithm requires 0(N log N) inter-processor communication overhead. Thus in effect, the algorithm constructs each rational interpolant using O(log N) parallel arithmetic and O(log N) communication steps.