Three nearly scaling-invariant versions of an exterior point algorithm for linear programming

In this paper, we describe three versions of a primal exterior point Simplex type algorithm for solving linear programming problems. Also, these algorithms are not affected mainly by scaling techniques. We compare their practical effectiveness versus the revised primal Simplex algorithm (our implementation) and the MATLAB’s implementations of Simplex and Interior Point Method. A computational study on randomly generated sparse linear programs is presented to establish the practical value of the proposed versions. The results are very encouraging and verify the superiority of the exterior point versions over the other algorithms either using scaling techniques or not.     

Parallel algorithms for global optimization

In this paper, we report results of implementations of algorithms designed (i) to solve the global optimization problem (GOP) and (ii) to run on a parallel network of transputers. There have always been two alternative approaches to the solution of the GOP, probabilistic and deterministic. Interval methods can be implemented on our network of transputers using Concurrent ADA, and a secondary objective of the tests reported was to investigate the relative computer times required by parallel interval algorithms compared to probabilistic methods.     

Parallel Implementation of Synchronous Type Artificial Bee Colony Algorithm for Global Optimization

Evolutionary algorithms often need huge running times when solving large-scale optimization problems. One of the solutions for this issue is to introduce parallelization into the algorithm. To benefit from this approach for the artificial bee colony optimization algorithm, we present a new synchronous and parallel version of the algorithm. Performances of the proposed version and the original asynchronous algorithm are compared in terms of efficiency and speedup. Algorithms are competed to solve 20 large-scale global optimization problems. Comparative results show that the proposed parallel algorithm is still efficient as asynchronous version while it requires much less time to solve complex and large problems.     

Automatic parallel generation of tetrahedral grids by using a domain decomposition approach

An algorithm for the automatic parallel generation of three-dimensional unstructured grids based on geometric domain decomposition is proposed. A software package based on this algorithm is described. Examples of generating meshes for some application problems on a multiprocessor computer are presented. It is shown that the parallel algorithm can significantly (by a factor of several tens) reduce the mesh generation time. Moreover, it can easily generate meshes with as many as 5 × 10⁷ elements, which can hardly be generated sequentially. Issues concerning the speedup and the improvement of the efficiency of the computations and of the quality of the resulting meshes are discussed.     

A bisection-extreme point search algorithm for optimizing over the efficient set in the linear dependence case

The algorithms and algorithmic ideas currently available for globally optimizing linear functions over the efficient sets of multiple objective linear programs either use nonstandard subroutines or cannot yet be implemented for lack of sufficient development. In this paper a Bisection-Extreme Point Search Algorithm is presented for globally solving a large class of such problems. The algorithm finds an exact, globally-optimal solution after a finite number of iterations. It can be implemented by using only well-known pivoting and optimization subroutines, and it is adaptable to large scale problems or to problems with many local optima.     

Parallel algorithms for nonlinear programming problems

This paper describes several parallel algorithms for solving nonlinear programming problems. Two approaches where parallelism can successfully be introduced have been explored: a quadratic approximation method based on penalty function and a dual method. These methods are improved by using two algorithms originally proposed for solving unconstrained problems: the parallel variable metric algorithm and the parallel Jacobson-Oksman algorithm. Even though general problems are dealt with, particular emphasis is placed on the potential of these parallel methods for separable programming problems. The numerical effectiveness of the algorithms is demonstrated on a set of test problems using a Cray-1S vector computer and serial computers (with respect to sequential versions of the same methods).These studies were sponsored in part by the CERT. The author would particularly like to thank Ph. Berger (LSI-ENSEEIHT), the researchers of the DERI (CERT) and of the Groupe Structures, Aerospatiale, for their assistance.     

A shortest path algorithm in robotics and its implementation on the FPS T-20 hypercube

A broad class of problems involving the optimal control of robot arms can be formulated as dynamic programming problems whose structure is particularly attractive for parallel processing. For certain simple cost functions the dynamic programming formulation reduces to determining the shortest path through a network. This algorithm has been implemented on a Floating Point Systems' T-20 hypercube computer. An analysis of the performance of the algorithm provides several important insights into the interplay between problem size and the number of processors in a parallel computer. The results also underscore the potential for parallel computers in real-time control applications.This work was supported in part by the Office of Naval Research, Contract N 00014-86-K-0693.     

Efficient Parallel Algorithms for the Minimum Cost Flow Problem

In this paper, we propose efficient parallel implementations of the auction/sequential shortest path and the -relaxation algorithms for solving the linear minimum cost flow problem. In the parallel auction algorithm, several augmenting paths can be found simultaneously, each of them starting from a different node with positive surplus. Convergence results of an asynchronous version of the algorithm are also given. For the -relaxation method, there exist already parallel versions implemented on CM-5 and CM-2; our implementation is the first on a shared memory multiprocessor. We have obtained significant speedup values for the algorithms considered; it turns out that our implementations are effective and efficient.     

Algorithms for solving inverse geophysical problems on parallel computing systems

For solving inverse gravimetry problems, efficient stable parallel algorithms based on iterative gradient methods are proposed. For solving systems of linear algebraic equations with block-tridiagonal matrices arising in geoelectrics problems, a parallel matrix sweep algorithm, a square root method, and a conjugate gradient method with preconditioner are proposed. The algorithms are implemented numerically on a parallel computing system of the Institute of Mathematics and Mechanics (PCS-IMM), NVIDIA graphics processors, and an Intel multi-core CPU with some new computing technologies. The parallel algorithms are incorporated into a system of remote computations entitled “Specialized Web-Portal for Solving Geophysical Problems on Multiprocessor Computers.” Some problems with “quasi-model” and real data are solved.     

Parallel collocation solution of index-1 BVP-DAEs arising from constrained optimal control problems

The indirect solution of constrained optimal control problems gives rise to two-point boundary value problems (BVPs) that involve index-1 differential-algebraic equations (DAEs) and inequality constraints. This paper presents a parallel collocation algorithm for the solution of these inequality constrained index-1 BVP-DAEs. The numerical algorithm is based on approximating the DAEs using piecewise polynomials on a nonuniform mesh. The collocation method is realized by requiring that the BVP-DAE be satisfied at Lobatto points within each interval of the mesh. A Newton interior-point method is used to solve the collocation equations, and maintain feasibility of the inequality constraints. The implementation of the algorithm involves: (i) parallel evaluation of the collocation equations; (ii) parallel evaluation of the system Jacobian; and (iii) parallel solution of a boarded almost block diagonal (BABD) system to obtain the Newton search direction. Numerical examples show that the parallel implementation provides significant speedup when compared to a sequential version of the algorithm.     

Parallel algorithms for solving linear systems with block-tridiagonal matrices on multi-core CPU with GPU

For solving systems of linear algebraic equations with block-tridiagonal matrices arising in geoelectrics problems, the parallel matrix sweep algorithm, conjugate gradient method with preconditioner, and square root method are proposed and implemented numerically on multi-core CPU Intel with graphics processors NVIDIA. Investigation of efficiency and optimization of parallel algorithms for solving the problem with quasi-model data are performed.     

Experiments in Solving Mixed Integer Programming Problems on a Small Array of Transputers

The time-consuming process of solving large-scale Mixed Integer Programming problems using the branch-and-bound technique can be speeded up by introducing a degree of parallelism into the basic algorithm. This paper describes the development and implementation of a parallel branch-and-bound algorithm created by adapting a commercial MIP solver. Inherent in the design of this software are certain ad hoc methods, the use of which are necessary in the effective solution of real problems. The extent to which these ad hoc methods can successfully be transferred to a parallel environment, in this case an array of at most nine transputers, is discussed. Computational results on a variety of real integer programming problems are reported.     

An improved origin-based algorithm for solving the combined distribution and assignment problem

This paper is to further study the origin-based (OB) algorithm for solving the combined distribution and assignment (CDA) problem, where the trip distribution follows a gravity model and the traffic assignment is a user-equilibrium model. Recently, the OB algorithm has shown to be superior to the Frank–Wolfe (FW) algorithm for the traffic assignment (TA) problem and better than the Evans’ algorithm for the CDA problem in both computational time and solution accuracy. In this paper, a modified origin–destination (OD) flow update strategy proposed by Huang and Lam [Huang, H.J., Lam, W.H.K., 1992. Modified Evans’ algorithms for solving the combined trip distribution and assignment problem. Transportation Research B 26 (4), 325–337] for CDA with the Evans’ algorithm is adopted to improve the OB algorithm for solving the CDA problem. Convergence proof of the improved OB algorithm is provided along with some preliminary computational results to demonstrate the effect of the modified OD flow update strategy embedded in the OB algorithm.     

Proximal minimizations with D-functions and the massively parallel solution of linear network programs

This paper discusses the massively parallel solution of linear network programs. It integrates the general algorithmic framework of proximal minimization with D-functions (PMD) with primal-dual row-action algorithms. Three alternative algorithmic schemes are studied: quadratic proximal point, entropic proximal point, and least 2-norm perturbations. Each is solving a linear network problem by solving a sequence of nonlinear approximations. The nonlinear subproblems decompose for massively parallel computing. The three algorithms are implemented on a Connection Machine CM-2 with up to 32K processing elements, and problems with up to 16 million variables are solved. A comparison of the three algorithms establishes their relative efficiency. Numerical experiments also establish the best internal tactics which can be used when implementing proximal minimization algorithms. Finally, the new algorithms are compared with an implementation of the network simplex algorithm executing on a CRAY Y-MP vector supercomputer.     

Mesh selection for stiff two-point boundary value problems

This paper is concerned with the mesh selection algorithm of COLSYS, a well known collocation code for solving systems of boundary value problems. COLSYS was originally designed to solve non-stiff and mildly stiff problems only. In this paper we show that its performance for solving extremely stiff problems can be considerably improved by modifying its error estimation and mesh selection algorithms. Numerical examples indicate the superiority of the modified algorithm.Dedicated to John Butcher on the occasion of his sixtieth birthday     

Parallel Dantzig–Wolfe decomposition of petroleum production allocation problems

This article discusses the optimization of a petroleum production allocation problem through a parallel Dantzig–Wolfe algorithm. Petroleum production allocation problems are problems in which the determination of optimal production rates, lift gas rates and well connections are the central decisions. The motivation for modelling and solving such optimization problems stems from the value that lies in an increased production rate and the current lack of integrated software that considers petroleum production systems as a whole. Through our computational study, which is based on realistic production data from the Troll West field, we show the increase in computational efficiency that a parallel Dantzig–Wolfe algorithm offers. In addition, we show that previously implemented standard parallel algorithms lead to an inefficient use of parallel resources. A more advanced parallel algorithm is therefore developed to improve efficiency, making it possible to scale the algorithm by adding more CPUs and thus approach a reasonable solution time for realistic-sized problems.     

Parallel globally adaptive quadrature on the KSR-1

New algorithms for parallel one-dimensional globally adaptive quadrature are developed. The algorithms are implemented on a Kendall Square Research KSR-1 parallel computer and numerical results are presented. The most successful algorithm gives significant speedups on a range of hard problems, including ones with singular integrands. Both authors acknowledge the support of the EEC Esprit Basic Research Action Programme, Project 6634 (APPARC). The second author acknowledges the support of the NATO Collaborative Research Grant 920037.     

Parallel pivotal algorithm for solving the linear complementarity problem

We propose a parallel implementation of the classical Lemke's algorithm for solving the linear complementarity problem. The algorithm is designed for a loosely coupled network of computers which is characterized by relatively high communication costs. We provide an accurate prediction of speedup based on a simple operation count. The algorithm produces speedup nearp, wherep is the number of processors, when tested on large problems as demonstrated by computational results on the CRYSTAL token-ring multicomputer and the Sequent Balance 21000 multiprocessor.This material is based on research supported by National Science Foundation Grants DCR-84-20963 and DCR-850-21228 and by Air Force Office of Scientific Research Grants AFSOR-86-0172 and AFSOR-86-0255 while the author was at the University of Wisconsin, Madison, Wisconsin.     

Parallel computation of two-point boundary-value problems via particular solutions

Nonlinear two-point boundary-value problems (TPBVP) can be reduced to the iterative solution of a sequence of linear problems by means of quasilinearization techniques. Therefore, the efficient solution of linear problems is the key to the efficient solution of nonlinear problems.Among the techniques available for solving linear two-point boundary-value problems, the method of particular solutions (MPS) is particularly attractive in that it employs only one differential system, the original nonhomogeneous system, albeit with different initial conditions. This feature of MPS makes it ideally suitable for implementation on parallel computers in that the following requirements are met: the computational effort is subdivided into separate tasks (particular solutions) assigned to the different processors; the tasks have nearly the same size; there is little intercommunication between the tasks.For the TPBVP, the speedup achievable is ofO(n), wheren is the dimension of the state vector, hence relatively modest for the differential systems of interest in trajectory optimization and guidance. This being the case, we transform the TPBVP into a multi-point boundary-value problem (MPBVP) involvingm time subintervals, withm–1 continuity conditions imposed at the interface of contiguous subintervals. For the MPBVP, the speedup achievable is ofO(mn), hence substantially higher than that achievable for the TPBVP. It reduces toO(m) if the parallelism is implemented only in the time domain and not in the state domain.A drawback of the multi-point approach is that it requires the solution of a large linear algebraic system for the constants of the particular solutions. This drawback can be offset by exploiting the particular nature of the interface conditions: if the vector of constants for the first subinterval is known, the vector of constants for the subsequent subintervals can be obtained with linear transformations. Using decomposition techniques together with the discrete version of MPS, the size of the linear algebraic system for the multi-point case becomes the same as that for the two-point case.Numerical tests on the Intel iPSC/860 computer show that substantial speedup can be achieved via parallel algorithms vis-a-vis sequential algorithms. Therefore, the present technique has considerable interest for real-time trajectory optimization and guidance.Dedicated to the Memory of Professor Jan M. SkowronskiThis paper, based on Refs. 1–3, is a much condensed version of the material contained in these references.The technical assistance of the Research Center on Parallel Computation of Rice University, Houston, Texas is gratefully acknowledged.     

A faster LU decomposition for parallelC programs

This report introduces a faster parallel LU decomposition algorithm that gives a speedup almost equal to the number of nodes used. The new algorithm takes an advantage of an importantC feature that lays out a matrix using a row major scheme and is based on the currently widely used LU decomposition algorithm with one major modification to eliminate most of the communication overhead. Empirical results are included in this report. For example, solving a dense matrix that contains 100,000,000 elements gives a speedup of 50 when executed on 50 nodes of an Intel Paragon in parallel.